diff --git a/.gitignore b/.gitignore
index f2471a36d3..74875645f9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,9 @@ postgres/pgsql-test/output/
 .env.local
 graphql/server/logs/
 graphql/server/*.heapsnapshot
+scripts/scale-validate/out/
+scripts/scale-validate/fleet*.json
+scripts/scale-validate/drifted.json
+scripts/scale-spike/
+packages/perf-harness/perf-out/
+/metrics.jsonl
diff --git a/graphile/graphile-cache/src/__tests__/counters.test.ts b/graphile/graphile-cache/src/__tests__/counters.test.ts
new file mode 100644
index 0000000000..5b3ec01be3
--- /dev/null
+++ b/graphile/graphile-cache/src/__tests__/counters.test.ts
@@ -0,0 +1,120 @@
+import {
+  cacheCounters,
+  clearMatchingEntries,
+  getCacheConfig,
+  getCacheCounters,
+  graphileCache,
+  type GraphileCacheEntry
+} from '../graphile-cache';
+
+/**
+ * Counter instrumentation regression tests. The counters are process-global and
+ * mutable, so every assertion is a DELTA against a snapshot captured immediately
+ * before the action — robust to test ordering and to fire-and-forget disposals from
+ * other suites. The eviction and disposal increments happen synchronously inside
+ * graphileCache.delete() (the dispose callback and the pre-await head of disposeEntry),
+ * so no tick is needed except for the async drain-timeout path.
+ */
+
+const tick = (ms = 60) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const makeEntry = (releaseDelayMs = 0): GraphileCacheEntry => {
+  const release = jest.fn(
+    () => new Promise<void>((resolve) => setTimeout(resolve, releaseDelayMs))
+  );
+  return {
+    pgl: { release } as unknown as GraphileCacheEntry['pgl'],
+    serv: {} as GraphileCacheEntry['serv'],
+    handler: {} as GraphileCacheEntry['handler'],
+    // Never .listen()ed in production; close() invokes its callback synchronously here.
+    httpServer: { close: (cb: () => void) => cb() } as unknown as GraphileCacheEntry['httpServer'],
+    cacheKey: 'mock',
+    createdAt: Date.now()
+  };
+};
+
+describe('cacheCounters increment on eviction/disposal', () => {
+  afterEach(async () => {
+    graphileCache.clear();
+    await tick();
+  });
+
+  it('counts an LRU eviction (fresh entry, plain delete) and a disposal', () => {
+    const before = getCacheCounters();
+    const key = 'counter-lru-1';
+    graphileCache.set(key, makeEntry(0));
+    graphileCache.delete(key); // fresh + not manual → reason 'lru'; disposeEntry runs
+
+    const after = getCacheCounters();
+    expect(after.evictions.lru).toBe(before.evictions.lru + 1);
+    expect(after.disposals).toBe(before.disposals + 1);
+  });
+
+  it('counts a TTL eviction when the entry is older than the configured ttl', () => {
+    const before = getCacheCounters();
+    const key = 'counter-ttl-1';
+    const entry = makeEntry(0);
+    // Backdate our own createdAt beyond the idle-ttl so getEvictionReason returns 'ttl'.
+    entry.createdAt = Date.now() - getCacheConfig().ttl - 1_000;
+    graphileCache.set(key, entry);
+    graphileCache.delete(key);
+
+    const after = getCacheCounters();
+    expect(after.evictions.ttl).toBe(before.evictions.ttl + 1);
+  });
+
+  it('counts a manual eviction via clearMatchingEntries', () => {
+    const before = getCacheCounters();
+    graphileCache.set('counter-manual-1', makeEntry(0));
+    const cleared = clearMatchingEntries(/^counter-manual-/);
+
+    expect(cleared).toBe(1);
+    const after = getCacheCounters();
+    expect(after.evictions.manual).toBe(before.evictions.manual + 1);
+  });
+});
+
+describe('cacheCounters.drainTimeouts', () => {
+  const prev = process.env.GRAPHILE_CACHE_DRAIN_TIMEOUT_MS;
+  afterEach(async () => {
+    if (prev === undefined) delete process.env.GRAPHILE_CACHE_DRAIN_TIMEOUT_MS;
+    else process.env.GRAPHILE_CACHE_DRAIN_TIMEOUT_MS = prev;
+    graphileCache.clear();
+    await tick();
+  });
+
+  it('increments when disposal drains past the timeout with a request still in flight', async () => {
+    process.env.GRAPHILE_CACHE_DRAIN_TIMEOUT_MS = '1'; // one 100ms poll cycle, then give up
+    const before = getCacheCounters();
+    const key = 'counter-drain-1';
+    const entry = makeEntry(0);
+    entry.inflight = 1; // never drops → drain loop hits the timeout branch
+
+    graphileCache.set(key, entry);
+    graphileCache.delete(key); // fire-and-forget disposeEntry begins draining
+
+    await tick(250); // allow the poll cycle + timeout to elapse
+
+    const after = getCacheCounters();
+    expect(after.drainTimeouts).toBe(before.drainTimeouts + 1);
+    // Disposal still proceeds after the drain timeout.
+    expect((entry.pgl as unknown as { release: jest.Mock }).release).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('getCacheCounters snapshot isolation', () => {
+  it('returns a deep copy that cannot mutate the live counters', () => {
+    const before = getCacheCounters();
+    const snapshot = getCacheCounters();
+    snapshot.disposals += 1_000;
+    snapshot.evictions.lru += 1_000;
+    snapshot.drainTimeouts += 1_000;
+
+    const after = getCacheCounters();
+    expect(after.disposals).toBe(before.disposals);
+    expect(after.evictions.lru).toBe(before.evictions.lru);
+    expect(after.drainTimeouts).toBe(before.drainTimeouts);
+    // Sanity: the live object is the same instance across reads.
+    expect(cacheCounters.disposals).toBe(after.disposals);
+  });
+});
diff --git a/graphile/graphile-cache/src/__tests__/disposal-and-cap.test.ts b/graphile/graphile-cache/src/__tests__/disposal-and-cap.test.ts
new file mode 100644
index 0000000000..f272704899
--- /dev/null
+++ b/graphile/graphile-cache/src/__tests__/disposal-and-cap.test.ts
@@ -0,0 +1,201 @@
+import { EventEmitter } from 'events';
+import {
+  ensureCacheHeadroom,
+  getCacheConfig,
+  graphileCache,
+  type GraphileCacheEntry,
+  invokeEntryHandler,
+} from '../graphile-cache';
+
+/**
+ * Regression tests for the schema-builder OOM fix.
+ *
+ * 1. Disposal guard is entry-scoped, not key-scoped. The previous string-keyed guard
+ *    skipped pgl.release() for a rebuilt entry that shared a key with an entry still
+ *    mid-release (the "same-key disposal race"). These tests pin the corrected behaviour:
+ *    every distinct entry is released exactly once, while the SAME entry is never
+ *    double-disposed.
+ * 2. getCacheConfig honours GRAPHILE_CACHE_MAX and otherwise returns a heap-aware default
+ *    bounded to a sane range (a count-only default of 50 × ~0.5GB/instance was the OOM).
+ */
+
+const tick = (ms = 60) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const makeEntry = (releaseDelayMs = 0): GraphileCacheEntry => {
+  const release = jest.fn(
+    () => new Promise<void>((resolve) => setTimeout(resolve, releaseDelayMs)),
+  );
+  return {
+    pgl: { release } as unknown as GraphileCacheEntry['pgl'],
+    serv: {} as GraphileCacheEntry['serv'],
+    handler: {} as GraphileCacheEntry['handler'],
+    // Never .listen()ed in production; close() invokes its callback synchronously here.
+    httpServer: { close: (cb: () => void) => cb() } as unknown as GraphileCacheEntry['httpServer'],
+    cacheKey: 'mock',
+    createdAt: Date.now(),
+  };
+};
+
+describe('graphile-cache disposal guard (same-key race)', () => {
+  it('disposes a rebuilt entry on the same key while a prior entry is mid-release', async () => {
+    const key = 'race-key-1';
+    const a = makeEntry(40); // a.release() stays pending while b is disposed
+    const b = makeEntry(0);
+
+    graphileCache.set(key, a);
+    graphileCache.delete(key); // -> disposeEntry(a) begins, a.release() in flight
+    graphileCache.set(key, b); // key was free; inserts b
+    graphileCache.delete(key); // -> disposeEntry(b) MUST NOT be skipped by the guard
+
+    await tick(120);
+
+    // The bug: the old string-keyed guard left `key` parked while a.release() was pending,
+    // so b.release() was never called (would be 0 here).
+    expect((a.pgl as unknown as { release: jest.Mock }).release).toHaveBeenCalledTimes(1);
+    expect((b.pgl as unknown as { release: jest.Mock }).release).toHaveBeenCalledTimes(1);
+  });
+
+  it('never disposes the same entry twice', async () => {
+    const key = 'race-key-2';
+    const a = makeEntry(0);
+
+    graphileCache.set(key, a);
+    graphileCache.delete(key); // dispose a
+    graphileCache.set(key, a); // re-insert the SAME entry object
+    graphileCache.delete(key); // dispose again -> guard must skip (already disposed)
+
+    await tick();
+
+    expect((a.pgl as unknown as { release: jest.Mock }).release).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('graphile-cache heap-aware capacity', () => {
+  const prev = process.env.GRAPHILE_CACHE_MAX;
+  afterEach(() => {
+    if (prev === undefined) delete process.env.GRAPHILE_CACHE_MAX;
+    else process.env.GRAPHILE_CACHE_MAX = prev;
+  });
+
+  it('honours an explicit GRAPHILE_CACHE_MAX', () => {
+    process.env.GRAPHILE_CACHE_MAX = '7';
+    expect(getCacheConfig().max).toBe(7);
+  });
+
+  it('falls back to a bounded heap-aware default when unset', () => {
+    delete process.env.GRAPHILE_CACHE_MAX;
+    const { max } = getCacheConfig();
+    // Bounded within [1, 50]: at least one instance must be admitted, but the
+    // floor must never exceed what the heap budget says fits (a floor of 3
+    // over-admitted 1.3GB instances on a 2GB heap and aborted the process).
+    expect(max).toBeGreaterThanOrEqual(1);
+    expect(max).toBeLessThanOrEqual(50);
+  });
+
+  it('ignores a non-numeric GRAPHILE_CACHE_MAX (falls back to heap-aware default)', () => {
+    process.env.GRAPHILE_CACHE_MAX = 'not-a-number';
+    const { max } = getCacheConfig();
+    expect(max).toBeGreaterThanOrEqual(1);
+    expect(max).toBeLessThanOrEqual(50);
+  });
+
+  it('admits only one instance when the per-instance estimate exceeds half the heap', () => {
+    delete process.env.GRAPHILE_CACHE_MAX;
+    const prevEstimate = process.env.GRAPHILE_CACHE_INSTANCE_HEAP_BYTES;
+    // Larger than any plausible test-runner heap budget => budgeted count is 0
+    // and the floor of 1 must win (never the old floor of 3).
+    process.env.GRAPHILE_CACHE_INSTANCE_HEAP_BYTES = String(64 * 1024 * 1024 * 1024);
+    try {
+      expect(getCacheConfig().max).toBe(1);
+    } finally {
+      if (prevEstimate === undefined) delete process.env.GRAPHILE_CACHE_INSTANCE_HEAP_BYTES;
+      else process.env.GRAPHILE_CACHE_INSTANCE_HEAP_BYTES = prevEstimate;
+    }
+  });
+});
+
+// A minimal express-like response: an EventEmitter so invokeEntryHandler can hook
+// 'finish'/'close', cast to the express type it expects.
+const makeRes = () => new EventEmitter() as unknown as Parameters<typeof invokeEntryHandler>[2];
+const fakeReq = {} as Parameters<typeof invokeEntryHandler>[1];
+const fakeNext = (() => undefined) as Parameters<typeof invokeEntryHandler>[3];
+
+describe('invokeEntryHandler in-flight refcounting', () => {
+  it('increments while serving and releases exactly once across finish+close', () => {
+    const entry = makeEntry();
+    const handler = jest.fn();
+    entry.handler = handler as unknown as GraphileCacheEntry['handler'];
+
+    const res = makeRes();
+    expect(invokeEntryHandler(entry, fakeReq, res, fakeNext)).toBe(true);
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(entry.inflight).toBe(1);
+
+    (res as unknown as EventEmitter).emit('finish');
+    expect(entry.inflight).toBe(0);
+    // 'close' always follows 'finish' in Node; the release must be idempotent.
+    (res as unknown as EventEmitter).emit('close');
+    expect(entry.inflight).toBe(0);
+  });
+
+  it('refuses a disposing entry without invoking the handler', () => {
+    const entry = makeEntry();
+    const handler = jest.fn();
+    entry.handler = handler as unknown as GraphileCacheEntry['handler'];
+    entry.disposing = true;
+
+    expect(invokeEntryHandler(entry, fakeReq, makeRes(), fakeNext)).toBe(false);
+    expect(handler).not.toHaveBeenCalled();
+  });
+});
+
+describe('disposeEntry drains in-flight requests before release', () => {
+  it('waits for inflight to reach 0, then releases exactly once', async () => {
+    const key = 'drain-key-1';
+    const entry = makeEntry(0);
+    entry.inflight = 1; // simulate a request mid-flight
+
+    graphileCache.set(key, entry);
+    graphileCache.delete(key); // disposal starts; must poll instead of releasing
+
+    await tick(120); // one poll cycle elapsed, request still in flight
+    expect((entry.pgl as unknown as { release: jest.Mock }).release).not.toHaveBeenCalled();
+
+    entry.inflight = 0; // request completes
+    await tick(250); // allow the next poll cycle to observe it
+
+    expect((entry.pgl as unknown as { release: jest.Mock }).release).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('ensureCacheHeadroom', () => {
+  const prevMax = process.env.GRAPHILE_CACHE_MAX;
+  afterEach(() => {
+    if (prevMax === undefined) delete process.env.GRAPHILE_CACHE_MAX;
+    else process.env.GRAPHILE_CACHE_MAX = prevMax;
+    graphileCache.clear();
+  });
+
+  it('evicts least-recently-used entries until a build slot is free', async () => {
+    process.env.GRAPHILE_CACHE_MAX = '2';
+    const a = makeEntry(0);
+    const b = makeEntry(0);
+    graphileCache.set('headroom-a', a);
+    graphileCache.set('headroom-b', b);
+    graphileCache.get('headroom-a'); // touch a → b becomes LRU-oldest
+
+    const evicted = ensureCacheHeadroom(1);
+
+    expect(evicted).toBe(1);
+    expect(graphileCache.has('headroom-a')).toBe(true);
+    expect(graphileCache.has('headroom-b')).toBe(false);
+    await tick(); // let the fire-and-forget disposal settle before clear()
+  });
+
+  it('no-ops when under capacity', () => {
+    process.env.GRAPHILE_CACHE_MAX = '5';
+    graphileCache.set('headroom-c', makeEntry(0));
+    expect(ensureCacheHeadroom(1)).toBe(0);
+    expect(graphileCache.has('headroom-c')).toBe(true);
+  });
+});
diff --git a/graphile/graphile-cache/src/__tests__/governor.test.ts b/graphile/graphile-cache/src/__tests__/governor.test.ts
new file mode 100644
index 0000000000..19ae8df6e6
--- /dev/null
+++ b/graphile/graphile-cache/src/__tests__/governor.test.ts
@@ -0,0 +1,83 @@
+import {
+  computeCapacityFromBudget,
+  getCacheCounters,
+  getMemoryPressure,
+  shouldRefuseBuild
+} from '../graphile-cache';
+
+const MB = 1024 * 1024;
+
+describe('computeCapacityFromBudget (two-constraint capacity model)', () => {
+  it('matches the live capacity-2 proof: 3584MB heap with 1.45GB instances', () => {
+    // r2-div-k1: two ~1.35GB instances resident (heapMax 2750MB), rebuild safe
+    // because evict-before-build frees a slot ahead of the transient peak.
+    expect(computeCapacityFromBudget(3584 * MB, 1450 * MB, 256 * MB, 768 * MB)).toBe(2);
+  });
+
+  it('gives capacity 1 on a 2GB heap with measured 1.45GB instances', () => {
+    expect(computeCapacityFromBudget(2048 * MB, 1450 * MB, 256 * MB, 768 * MB)).toBe(1);
+  });
+
+  it('never returns less than 1 even when nothing fits', () => {
+    expect(computeCapacityFromBudget(896 * MB, 1450 * MB, 256 * MB, 768 * MB)).toBe(1);
+  });
+
+  it('caps at 50 for tiny instances on big heaps', () => {
+    expect(computeCapacityFromBudget(64 * 1024 * MB, 4 * MB, 256 * MB, 768 * MB)).toBe(50);
+  });
+
+  it('applies the rebuild constraint when it is the binding one', () => {
+    // Residency alone would allow 3 (3*1000+256 <= 3500), but a rebuild with
+    // 2 residents (2*1000 + 256 + 900 = 3156 <= 3500) is the binding bound:
+    // byResidency = floor((3500-256)/1000) = 3
+    // byRebuild   = floor((3500-256-900)/1000) + 1 = 2 + 1 = 3
+    expect(computeCapacityFromBudget(3500 * MB, 1000 * MB, 256 * MB, 900 * MB)).toBe(3);
+    // Shrink the heap so the rebuild constraint bites:
+    // byResidency = floor((3300-256)/1000) = 3
+    // byRebuild   = floor((3300-256-900)/1000) + 1 = 2 + 1 = 3 -> still 3;
+    // push harder:
+    // byResidency(3256) = 3, byRebuild(3256) = floor(2100/1000)+1 = 3
+    // byResidency(3200) = 2 — residency binds again. Use a bigger reserve:
+    expect(computeCapacityFromBudget(3300 * MB, 1000 * MB, 256 * MB, 1500 * MB)).toBe(2);
+  });
+});
+
+describe('memory governor pressure gate', () => {
+  const cleanup: Array<() => void> = [];
+  afterEach(() => {
+    while (cleanup.length) cleanup.pop()!();
+  });
+
+  const setEnv = (key: string, value: string) => {
+    const prev = process.env[key];
+    process.env[key] = value;
+    cleanup.push(() => {
+      if (prev === undefined) delete process.env[key];
+      else process.env[key] = prev;
+    });
+  };
+
+  it('reports ok at normal test-process heap levels', () => {
+    expect(getMemoryPressure().level).toBe('ok');
+  });
+
+  it('refuses builds and counts them at critical pressure', () => {
+    // Force the critical watermark below any real process usage.
+    setEnv('GRAPHILE_MEMORY_GOVERNOR_CRITICAL', '0.0001');
+    setEnv('GRAPHILE_MEMORY_GOVERNOR_ELEVATED', '0.00005');
+    const before = getCacheCounters().buildRefusals;
+    const verdict = shouldRefuseBuild();
+    expect(verdict.level).toBe('critical');
+    expect(verdict.refuseBuild).toBe(true);
+    expect(getCacheCounters().buildRefusals).toBe(before + 1);
+  });
+
+  it('does not refuse builds at elevated pressure', () => {
+    setEnv('GRAPHILE_MEMORY_GOVERNOR_ELEVATED', '0.0001');
+    const before = getCacheCounters().buildRefusals;
+    const verdict = shouldRefuseBuild();
+    expect(verdict.level).toBe('elevated');
+    expect(verdict.refuseBuild).toBe(false);
+    expect(getCacheCounters().buildRefusals).toBe(before);
+  });
+});
diff --git a/graphile/graphile-cache/src/create-instance.ts b/graphile/graphile-cache/src/create-instance.ts
index fc4c625ae2..5787020a5a 100644
--- a/graphile/graphile-cache/src/create-instance.ts
+++ b/graphile/graphile-cache/src/create-instance.ts
@@ -10,6 +10,11 @@ const log = new Logger('graphile-cache:create');
 interface GraphileInstanceOptions {
   preset: any;
   cacheKey: string;
+  /**
+   * Database name backing this instance's pg pool. Stored on the entry so the
+   * graphile-cache pgCache cleanup callback can evict it when its pool is disposed.
+   */
+  dbname?: string;
   /**
    * When true, a RealtimeManager is created and started alongside the
    * PostGraphile instance.  The pool is extracted from the preset's
@@ -37,7 +42,7 @@ interface GraphileInstanceOptions {
 export const createGraphileInstance = async (
   opts: GraphileInstanceOptions
 ): Promise<GraphileCacheEntry> => {
-  const { preset, cacheKey, enableRealtime = false } = opts;
+  const { preset, cacheKey, dbname, enableRealtime = false } = opts;
 
   const pgl = postgraphile(preset);
   const serv = pgl.createServ(grafserv);
@@ -53,7 +58,9 @@ export const createGraphileInstance = async (
     handler,
     httpServer,
     cacheKey,
+    dbname,
     createdAt: Date.now(),
+    inflight: 0,
   };
 
   if (enableRealtime) {
diff --git a/graphile/graphile-cache/src/graphile-cache.ts b/graphile/graphile-cache/src/graphile-cache.ts
index 26bbb24c0a..ef257a6c62 100644
--- a/graphile/graphile-cache/src/graphile-cache.ts
+++ b/graphile/graphile-cache/src/graphile-cache.ts
@@ -1,8 +1,14 @@
 import { EventEmitter } from 'events';
+import { getHeapStatistics } from 'node:v8';
 import { Logger } from '@pgpmjs/logger';
 import { LRUCache } from 'lru-cache';
 import { pgCache } from 'pg-cache';
-import type { Express } from 'express';
+import type {
+  Express,
+  NextFunction as ExpressNextFunction,
+  Request as ExpressRequest,
+  Response as ExpressResponse,
+} from 'express';
 import type { Server as HttpServer } from 'http';
 import type { PostGraphileInstance } from 'postgraphile';
 import type { GrafservBase } from 'grafserv';
@@ -12,11 +18,45 @@ const log = new Logger('graphile-cache');
 // --- Time Constants ---
 export const ONE_HOUR_MS = 1000 * 60 * 60;
 export const FIVE_MINUTES_MS = 1000 * 60 * 5;
-const ONE_DAY = ONE_HOUR_MS * 24;
-const ONE_YEAR = ONE_DAY * 366;
+const SIX_HOURS_MS = ONE_HOUR_MS * 6;
 
 // --- Eviction Types ---
-export type EvictionReason = 'lru' | 'ttl' | 'manual';
+export type EvictionReason = 'lru' | 'ttl' | 'manual' | 'governor';
+
+// --- Cache Counters (in-process metrics) ---
+export interface CacheCounters {
+  evictions: { lru: number; ttl: number; manual: number; governor: number };
+  disposals: number;
+  drainTimeouts: number;
+  buildRefusals: number;
+}
+
+/**
+ * Cumulative in-process cache counters for the metrics sampler. Mutated in the LRU
+ * dispose callback (by eviction reason), in disposeEntry (each distinct disposal), and
+ * in the drain-timeout warning branch. Zero overhead when the sampler is disabled — the
+ * increments are a handful of integer bumps on paths that already do real teardown work.
+ * Read a stable snapshot via getCacheCounters().
+ */
+export const cacheCounters: CacheCounters = {
+  evictions: { lru: 0, ttl: 0, manual: 0, governor: 0 },
+  disposals: 0,
+  drainTimeouts: 0,
+  buildRefusals: 0
+};
+
+/**
+ * Snapshot the cache counters. Returns a deep copy so callers cannot mutate the live
+ * counters through the returned object.
+ */
+export function getCacheCounters(): CacheCounters {
+  return {
+    evictions: { ...cacheCounters.evictions },
+    disposals: cacheCounters.disposals,
+    drainTimeouts: cacheCounters.drainTimeouts,
+    buildRefusals: cacheCounters.buildRefusals
+  };
+}
 
 // --- Cache Event Emitter ---
 export interface CacheEvictionEvent {
@@ -43,30 +83,128 @@ export interface CacheConfig {
   ttl: number;
 }
 
+/**
+ * Empirically, a PostGraphile v5 instance that has served at least one GraphQL
+ * request retains ~0.5 GB of V8 heap (the fully-materialised GraphQL schema plus
+ * grafast's per-schema plan machinery; a build-only instance is far smaller, but
+ * every *cached* instance is, by definition, one that serves requests). The cache
+ * therefore CANNOT be bounded by entry count alone: `max` heavy instances need
+ * `max * ~0.5GB` of resident heap, and once that exceeds the V8 old-space limit the
+ * process OOMs as distinct hosts fill the cache. A fixed default of 50 implies
+ * ~24 GB of resident schemas — far beyond any normal heap — which is the root cause
+ * of the schema-builder OOM. We derive a heap-aware default that budgets a fraction
+ * of the heap for cached instances. Override explicitly with GRAPHILE_CACHE_MAX, and
+ * tune the per-instance estimate with GRAPHILE_CACHE_INSTANCE_HEAP_BYTES.
+ */
+// ~0.5 GB retained per query-serving instance (measured against real provisioned apps
+// on a small catalog). NOTE: instance heap scales with the TOTAL pg catalog
+// (~21 KB per pg_class row measured) — on large multi-tenant catalogs set
+// GRAPHILE_CACHE_INSTANCE_HEAP_BYTES to a measured value (e.g. ~1.45 GB at 61k rows).
+const DEFAULT_INSTANCE_HEAP_BYTES = 512 * 1024 * 1024;
+// Heap reserved for the server itself: express, pools, request working set
+// (~+250 MB was measured at 200 rps on top of the resident instance).
+const DEFAULT_BASE_RESERVE_BYTES = 256 * 1024 * 1024;
+// Heap reserved for ONE in-flight schema build's transient allocations
+// (introspection payload + gather + schema construction; >700 MB measured at a
+// 61k-pg_class catalog). Builds are serialized by the server's BuildSemaphore,
+// and ensureCacheHeadroom evicts down to (max - 1) residents before each build,
+// so exactly one transient of this size coexists with (max - 1) residents.
+const DEFAULT_BUILD_RESERVE_BYTES = 768 * 1024 * 1024;
+// At least one instance must be admitted or nothing can ever build — but never
+// more than the heap budget says fit. A floor of 3 admitted two extra builds
+// the heap could not hold and aborted the process (V8 heap-limit SIGABRT)
+// before eviction ever ran.
+const MIN_CACHE_MAX = 1;
+const MAX_CACHE_MAX = 50;
+
+const parseEnvInt = (value: string | undefined, fallback: number): number => {
+  if (!value) return fallback;
+  const n = parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+
+/**
+ * Pure capacity math (exported for tests and diagnostics).
+ *
+ * Two constraints bound how many instances fit:
+ *   residency: max * perInstance + baseReserve            <= heapLimit
+ *   rebuild:   (max - 1) * perInstance + baseReserve
+ *              + buildReserve                             <= heapLimit
+ * (the rebuild constraint has (max - 1) residents because evict-before-build
+ * frees one slot before the transient allocation peaks — validated live: a
+ * 3584 MB heap holds TWO ~1.35 GB instances and still rebuilds safely).
+ */
+export function computeCapacityFromBudget(
+  heapLimit: number,
+  perInstance: number,
+  baseReserve: number = DEFAULT_BASE_RESERVE_BYTES,
+  buildReserve: number = DEFAULT_BUILD_RESERVE_BYTES,
+): number {
+  const byResidency = Math.floor((heapLimit - baseReserve) / perInstance);
+  const byRebuild = Math.floor((heapLimit - baseReserve - buildReserve) / perInstance) + 1;
+  const budgeted = Math.min(byResidency, byRebuild);
+  return Math.min(MAX_CACHE_MAX, Math.max(MIN_CACHE_MAX, budgeted));
+}
+
+/**
+ * Heap-aware default for the maximum number of cached PostGraphile instances.
+ * See computeCapacityFromBudget for the model. Tunables:
+ *   GRAPHILE_CACHE_INSTANCE_HEAP_BYTES — measured per-instance retained heap
+ *   GRAPHILE_CACHE_BASE_RESERVE_BYTES  — server base + request working set
+ *   GRAPHILE_CACHE_BUILD_RESERVE_BYTES — one build's transient peak
+ */
+function computeHeapAwareMax(): number {
+  try {
+    const heapLimit = getHeapStatistics().heap_size_limit; // reflects --max-old-space-size
+    const perInstance = parseEnvInt(
+      process.env.GRAPHILE_CACHE_INSTANCE_HEAP_BYTES,
+      DEFAULT_INSTANCE_HEAP_BYTES,
+    );
+    const baseReserve = parseEnvInt(
+      process.env.GRAPHILE_CACHE_BASE_RESERVE_BYTES,
+      DEFAULT_BASE_RESERVE_BYTES,
+    );
+    const buildReserve = parseEnvInt(
+      process.env.GRAPHILE_CACHE_BUILD_RESERVE_BYTES,
+      DEFAULT_BUILD_RESERVE_BYTES,
+    );
+    return computeCapacityFromBudget(heapLimit, perInstance, baseReserve, buildReserve);
+  } catch {
+    return MIN_CACHE_MAX;
+  }
+}
+
 /**
  * Get cache configuration from environment variables
  *
  * Supports:
- * - GRAPHILE_CACHE_MAX: Maximum number of entries (default: 50)
- * - GRAPHILE_CACHE_TTL_MS: TTL in milliseconds
- *   - Production default: ONE_YEAR
+ * - GRAPHILE_CACHE_MAX: Maximum number of entries. Default is heap-aware
+ *   (see computeHeapAwareMax) rather than a fixed 50, because each cached
+ *   instance retains ~0.5 GB and a count-only cap OOMs the process.
+ * - GRAPHILE_CACHE_INSTANCE_HEAP_BYTES: per-instance heap estimate for the
+ *   heap-aware default (default ~512 MB).
+ * - GRAPHILE_CACHE_TTL_MS: idle TTL in milliseconds (updateAgeOnGet refreshes it
+ *   on every hit, so this is an idle-expiry, not an absolute lifetime)
+ *   - Production default: SIX_HOURS_MS — an idle tenant's ~0.5 GB instance is
+ *     reclaimed within hours instead of pinned for a year; a later request
+ *     simply rebuilds it
  *   - Development default: FIVE_MINUTES_MS
  *
- * NOTE: This value should be <= PG_CACHE_MAX (also default: 50) so that
- * every cached PostGraphile instance has a live pool backing it.
+ * NOTE: This value should be <= PG_CACHE_MAX so that every cached PostGraphile
+ * instance has a live pool backing it.
  */
 export function getCacheConfig(): CacheConfig {
   const isDevelopment = process.env.NODE_ENV === 'development';
 
   const max = process.env.GRAPHILE_CACHE_MAX
-    ? parseInt(process.env.GRAPHILE_CACHE_MAX, 10)
-    : 50;
+    ? parseEnvInt(process.env.GRAPHILE_CACHE_MAX, computeHeapAwareMax())
+    : computeHeapAwareMax();
 
   const ttl = process.env.GRAPHILE_CACHE_TTL_MS
     ? parseInt(process.env.GRAPHILE_CACHE_TTL_MS, 10)
     : isDevelopment
       ? FIVE_MINUTES_MS
-      : ONE_YEAR;
+      : SIX_HOURS_MS;
 
   return { max, ttl };
 }
@@ -89,16 +227,61 @@ export interface GraphileCacheEntry {
   httpServer: HttpServer;
   cacheKey: string;
   createdAt: number;
+  /**
+   * Database name backing this instance's pg pool. Used to evict the entry when its
+   * pool is disposed (see the pgCache cleanup callback). Distinct from cacheKey, which
+   * on the public server is the request HOST, not the database.
+   */
+  dbname?: string;
   /** Optional RealtimeManager for cursor-tracked subscription delivery */
   realtimeManager?: { stop(): Promise<void> } | null;
+  /**
+   * Number of requests currently executing against this entry's handler.
+   * Maintained by invokeEntryHandler; disposeEntry drains to 0 (bounded by
+   * GRAPHILE_CACHE_DRAIN_TIMEOUT_MS) before releasing the instance so eviction
+   * cannot tear down a schema mid-request.
+   */
+  inflight?: number;
+  /** Set at the start of disposal; routing must treat the entry as a cache miss. */
+  disposing?: boolean;
 }
 
-// Track disposed entries to prevent double-disposal
-const disposedKeys = new Set<string>();
+// Track disposed entries to prevent double-disposal. Keyed by ENTRY IDENTITY (a WeakSet),
+// NOT by the cache key. A key-scoped guard caused a same-key disposal race: while entry A
+// for key K was mid `pgl.release()` (K parked in the guard), a rebuilt entry B for the SAME
+// key K could be evicted and its disposeEntry would short-circuit, silently skipping
+// B.pgl.release(). Guarding by entry identity disposes every distinct entry exactly once
+// while still allowing a rebuilt entry on the same key to be released.
+const disposedEntries = new WeakSet<GraphileCacheEntry>();
 
 // Track keys that are being manually evicted for accurate eviction reason
 const manualEvictionKeys = new Set<string>();
 
+// Track keys evicted by the memory governor for accurate eviction reason
+const governorEvictionKeys = new Set<string>();
+
+// Number of entries currently DRAINING (evicted from the cache but their ~GB of
+// heap still live until in-flight requests finish and pgl.release() completes).
+// Invisible to ensureCacheHeadroom (they are no longer cache entries), so build
+// admission must consult it: a build transient stacked on undrained instances is
+// what OOMed the soak (flush -> rebuild race).
+let drainingCount = 0;
+
+export const getDrainingCount = (): number => drainingCount;
+
+/**
+ * Hold a build until evicted instances have actually released their memory —
+ * or heap pressure is comfortable anyway, or the bounded wait expires (drains
+ * are themselves bounded by GRAPHILE_CACHE_DRAIN_TIMEOUT_MS).
+ */
+export async function waitForDrainSettle(timeoutMs = 20_000): Promise<void> {
+  const start = Date.now();
+  while (drainingCount > 0 && Date.now() - start < timeoutMs) {
+    if (getMemoryPressure().level === 'ok') return;
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+}
+
 /**
  * Dispose a PostGraphile v5 cache entry
  *
@@ -106,20 +289,53 @@ const manualEvictionKeys = new Set<string>();
  * 1. Closing the HTTP server if listening
  * 2. Releasing the PostGraphile instance (which internally releases grafserv)
  *
- * Uses disposedKeys set to prevent double-disposal when closeAllCaches()
- * explicitly disposes entries and then clear() triggers the dispose callback.
+ * Uses the disposedEntries WeakSet to prevent double-disposal of the same entry when
+ * closeAllCaches() explicitly disposes entries and then clear() triggers the dispose
+ * callback for the same entry.
  */
 const disposeEntry = async (entry: GraphileCacheEntry, key: string): Promise<void> => {
-  // Prevent double-disposal
-  if (disposedKeys.has(key)) {
+  // Prevent double-disposal of the SAME entry (guard by identity, not by key — see the
+  // disposedEntries declaration for why).
+  if (disposedEntries.has(entry)) {
     return;
   }
-  disposedKeys.add(key);
+  disposedEntries.add(entry);
+  cacheCounters.disposals += 1;
+  entry.disposing = true;
+  drainingCount += 1;
+  try {
+    await disposeEntryInner(entry, key);
+  } finally {
+    drainingCount -= 1;
+  }
+};
+
+const disposeEntryInner = async (entry: GraphileCacheEntry, key: string): Promise<void> => {
+
+  // Drain in-flight requests before tearing the instance down. The entry is already
+  // out of the cache (dispose fires post-removal), so no NEW requests can route here —
+  // invokeEntryHandler also refuses entries with `disposing` set. Bounded wait: a wedged
+  // request must not pin ~0.5 GB forever.
+  const drainTimeoutMs = parseEnvInt(process.env.GRAPHILE_CACHE_DRAIN_TIMEOUT_MS, 30_000);
+  const drainStart = Date.now();
+  while ((entry.inflight ?? 0) > 0 && Date.now() - drainStart < drainTimeoutMs) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if ((entry.inflight ?? 0) > 0) {
+    cacheCounters.drainTimeouts += 1;
+    log.warn(
+      `Disposing PostGraphile[${key}] with ${entry.inflight} request(s) still in flight after ${drainTimeoutMs}ms drain timeout`,
+    );
+  }
 
   log.debug(`Disposing PostGraphile[${key}]`);
   try {
-    // Close HTTP server if it's listening
-    if (entry.httpServer?.listening) {
+    // Close the HTTP server. create-instance builds it via createServer() but never
+    // .listen()s it, so `.listening` is always false — the old guard meant close() never
+    // ran. Closing unconditionally detaches grafserv's 'upgrade' listener; when the server
+    // was never listening, close() simply invokes the callback with ERR_SERVER_NOT_RUNNING
+    // (a harmless no-op here), so the Promise always resolves.
+    if (entry.httpServer) {
       await new Promise<void>((resolve) => {
         entry.httpServer.close(() => resolve());
       });
@@ -138,15 +354,18 @@ const disposeEntry = async (entry: GraphileCacheEntry, key: string): Promise<voi
     }
   } catch (err) {
     log.error(`Error disposing PostGraphile[${key}]:`, err);
-  } finally {
-    disposedKeys.delete(key);
   }
+  // No key cleanup needed: the WeakSet entry is reclaimed together with the entry by GC.
 };
 
 /**
  * Determine the eviction reason for a cache entry
  */
 const getEvictionReason = (key: string, entry: GraphileCacheEntry): EvictionReason => {
+  if (governorEvictionKeys.has(key)) {
+    governorEvictionKeys.delete(key);
+    return 'governor';
+  }
   if (manualEvictionKeys.has(key)) {
     manualEvictionKeys.delete(key);
     return 'manual';
@@ -165,6 +384,20 @@ const getEvictionReason = (key: string, entry: GraphileCacheEntry): EvictionReas
 // Get initial cache configuration
 const initialConfig = getCacheConfig();
 
+// Surface the resolved instance cap once at startup. Because each cached PostGraphile
+// instance retains ~0.5 GB, an oversized cap (relative to the heap) is the primary cause
+// of schema-builder OOM — make the chosen value visible to operators.
+try {
+  const heapLimitMb = Math.round(getHeapStatistics().heap_size_limit / (1024 * 1024));
+  const source = process.env.GRAPHILE_CACHE_MAX ? 'GRAPHILE_CACHE_MAX' : 'heap-aware default';
+  log.info(
+    `graphileCache max=${initialConfig.max} instances (${source}); heap limit ~${heapLimitMb}MB. ` +
+      `Each query-serving instance retains ~0.5GB; raise --max-old-space-size or lower GRAPHILE_CACHE_MAX if memory-constrained.`,
+  );
+} catch {
+  // ignore — logging is best-effort
+}
+
 // --- Graphile Cache ---
 export const graphileCache = new LRUCache<string, GraphileCacheEntry>({
   max: initialConfig.max,
@@ -173,6 +406,7 @@ export const graphileCache = new LRUCache<string, GraphileCacheEntry>({
   dispose: (entry, key) => {
     // Determine eviction reason before disposal
     const reason = getEvictionReason(key, entry);
+    cacheCounters.evictions[reason] += 1;
 
     // Emit eviction event
     cacheEvents.emitEviction({ key, reason, entry });
@@ -187,6 +421,169 @@ export const graphileCache = new LRUCache<string, GraphileCacheEntry>({
   }
 });
 
+/**
+ * Invoke an entry's Express handler with in-flight refcounting.
+ *
+ * Returns false WITHOUT invoking when the entry is already being disposed —
+ * callers must treat that as a cache miss (rebuild) or retry. On invocation,
+ * the refcount is incremented and released exactly once when the response
+ * finishes or the connection closes, which is what disposeEntry drains on.
+ */
+export function invokeEntryHandler(
+  entry: GraphileCacheEntry,
+  req: ExpressRequest,
+  res: ExpressResponse,
+  next: ExpressNextFunction,
+): boolean {
+  if (entry.disposing) {
+    return false;
+  }
+  entry.inflight = (entry.inflight ?? 0) + 1;
+  let released = false;
+  const release = () => {
+    if (!released) {
+      released = true;
+      entry.inflight = Math.max(0, (entry.inflight ?? 1) - 1);
+    }
+  };
+  // 'close' fires after 'finish' and also on aborted connections; release is idempotent.
+  res.once('finish', release);
+  res.once('close', release);
+  entry.handler(req, res, next);
+  return true;
+}
+
+/**
+ * Evict least-recently-used entries until there is room for `slots` new entries
+ * under the configured max. Called BEFORE building a new instance so the build's
+ * transient allocation (hundreds of MB) lands on a cache that has already shed
+ * an instance, instead of stacking a full cache + a build peak (the OOM shape).
+ */
+export function ensureCacheHeadroom(slots = 1): number {
+  const { max } = getCacheConfig();
+  let evicted = 0;
+  while (graphileCache.size > Math.max(0, max - slots)) {
+    // rkeys() iterates least-recently-used first
+    const oldestKey = graphileCache.rkeys().next().value as string | undefined;
+    if (oldestKey === undefined) break;
+    graphileCache.delete(oldestKey);
+    evicted++;
+  }
+  if (evicted > 0) {
+    log.info(`Evicted ${evicted} instance(s) before build to keep heap headroom (max=${max})`);
+  }
+  return evicted;
+}
+
+// --- Memory Governor ---
+export type MemoryPressureLevel = 'ok' | 'elevated' | 'critical';
+
+export interface MemoryPressure {
+  level: MemoryPressureLevel;
+  heapUsed: number;
+  heapLimit: number;
+  ratio: number;
+}
+
+const parseEnvFloat = (value: string | undefined, fallback: number): number => {
+  if (!value) return fallback;
+  const n = parseFloat(value);
+  return Number.isFinite(n) && n > 0 && n < 1 ? n : fallback;
+};
+
+/**
+ * Current heap pressure against V8's actually-exhaustible headroom
+ * (used / (used + total_available_size)).
+ *
+ * elevated (default >=85%): proactively evict idle instances ahead of the LRU
+ * schedule. critical (default >=92%): additionally REFUSE to start new schema
+ * builds (the caller responds 503; resident instances keep serving). A build's
+ * transient allocations are the largest single spike the process makes — at
+ * critical pressure admitting one converts degraded service into a V8
+ * heap-limit abort for every tenant on the box.
+ * Tunables: GRAPHILE_MEMORY_GOVERNOR_ELEVATED / GRAPHILE_MEMORY_GOVERNOR_CRITICAL.
+ */
+export function getMemoryPressure(): MemoryPressure {
+  const stats = getHeapStatistics();
+  const heapLimit = stats.heap_size_limit;
+  const heapUsed = process.memoryUsage().heapUsed;
+  // Ratio denominator is used + V8's own remaining-allocatable estimate, NOT
+  // heap_size_limit: the limit includes young-generation and reserved space the
+  // old space can never use, so with --max-old-space-size=512 the limit reads
+  // ~738MB while the process aborts near ~508MB used — a 0.69 "ratio" at the
+  // moment of death, leaving 0.85/0.92 watermarks unreachable exactly when they
+  // matter. used/(used+available) approaches 1.0 as the abort nears at every
+  // heap size.
+  const available = stats.total_available_size ?? Math.max(0, heapLimit - heapUsed);
+  const exhaustible = heapUsed + available;
+  const ratio = exhaustible > 0 ? heapUsed / exhaustible : 0;
+  const elevated = parseEnvFloat(process.env.GRAPHILE_MEMORY_GOVERNOR_ELEVATED, 0.85);
+  const critical = parseEnvFloat(process.env.GRAPHILE_MEMORY_GOVERNOR_CRITICAL, 0.92);
+  const level: MemoryPressureLevel = ratio >= critical ? 'critical' : ratio >= elevated ? 'elevated' : 'ok';
+  return { level, heapUsed, heapLimit, ratio };
+}
+
+/**
+ * Gate for new schema builds. Returns the pressure snapshot; when
+ * `refuseBuild` is true the caller must not start a build (respond 503 and
+ * count it). Cheap enough for the request path: one memoryUsage() call.
+ */
+export function shouldRefuseBuild(): MemoryPressure & { refuseBuild: boolean } {
+  const pressure = getMemoryPressure();
+  const refuseBuild = pressure.level === 'critical';
+  if (refuseBuild) {
+    cacheCounters.buildRefusals += 1;
+    log.warn(
+      `Refusing new schema build at critical heap pressure ` +
+        `(${Math.round(pressure.ratio * 100)}% of exhaustible headroom used; ` +
+        `heap limit ${Math.round(pressure.heapLimit / 1048576)}MB)`,
+    );
+  }
+  return { ...pressure, refuseBuild };
+}
+
+let governorTimer: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Periodic proactive eviction: at elevated/critical pressure, evict the
+ * least-recently-used instance (skipping in-flight ones) each tick until
+ * pressure clears. Disabled with GRAPHILE_MEMORY_GOVERNOR=0.
+ */
+export function startMemoryGovernor(intervalMs = 10_000): () => void {
+  if (process.env.GRAPHILE_MEMORY_GOVERNOR === '0') return () => {};
+  if (governorTimer) return stopMemoryGovernor;
+  governorTimer = setInterval(() => {
+    const pressure = getMemoryPressure();
+    if (pressure.level === 'ok') return;
+    // Evict ONE entry per tick, LRU first, preferring idle entries.
+    let victim: string | undefined;
+    for (const key of graphileCache.rkeys()) {
+      const entry = graphileCache.peek(key);
+      if (entry && !entry.disposing && (entry.inflight ?? 0) === 0) {
+        victim = key;
+        break;
+      }
+      if (victim === undefined) victim = key; // fall back to LRU even if busy
+    }
+    if (victim === undefined) return;
+    governorEvictionKeys.add(victim);
+    log.warn(
+      `Memory governor evicting PostGraphile[${victim}] at ${pressure.level} pressure ` +
+        `(heap ${Math.round(pressure.ratio * 100)}%)`,
+    );
+    graphileCache.delete(victim);
+  }, intervalMs);
+  if (typeof governorTimer.unref === 'function') governorTimer.unref();
+  return stopMemoryGovernor;
+}
+
+export function stopMemoryGovernor(): void {
+  if (governorTimer) {
+    clearInterval(governorTimer);
+    governorTimer = null;
+  }
+}
+
 // --- Cache Stats ---
 export interface CacheStats {
   size: number;
@@ -235,9 +632,12 @@ export function clearMatchingEntries(pattern: RegExp): number {
 const unregister = pgCache.registerCleanupCallback((pgPoolKey: string) => {
   log.debug(`pgPool[${pgPoolKey}] disposed - checking graphile entries`);
 
-  // Remove graphile entries that reference this pool key
+  // Remove graphile entries backed by this pool. Match on the entry's dbname (the pool is
+  // keyed by database name), NOT on cacheKey: on the public server cacheKey is the request
+  // HOST, which never contains the database name, so the old `cacheKey.includes(pgPoolKey)`
+  // test never matched and this safety valve was dead.
   graphileCache.forEach((entry, k) => {
-    if (entry.cacheKey.includes(pgPoolKey)) {
+    if (entry.dbname === pgPoolKey) {
       log.debug(`Removing graphileCache[${k}] due to pgPool[${pgPoolKey}] disposal`);
       manualEvictionKeys.add(k);
       graphileCache.delete(k);
@@ -281,11 +681,12 @@ export const closeAllCaches = async (verbose = false): Promise<void> => {
       // Wait for all disposals to complete
       await Promise.allSettled(disposePromises);
 
-      // Clear the cache after disposal (dispose callback will no-op due to disposedKeys)
+      // Clear the cache after disposal (dispose callback no-ops: each entry is already
+      // in the disposedEntries WeakSet from the explicit disposeEntry above).
       graphileCache.clear();
 
-      // Clear disposed keys tracking after full cleanup
-      disposedKeys.clear();
+      // The disposedEntries WeakSet needs no explicit clearing — entries are reclaimed by
+      // GC once the cache no longer references them.
       manualEvictionKeys.clear();
 
       // Close pg pools
diff --git a/graphile/graphile-cache/src/index.ts b/graphile/graphile-cache/src/index.ts
index e64be532b9..3dec3e4442 100644
--- a/graphile/graphile-cache/src/index.ts
+++ b/graphile/graphile-cache/src/index.ts
@@ -25,6 +25,28 @@ export {
   CacheStats,
   getCacheStats,
 
+  // In-process metrics counters
+  CacheCounters,
+  cacheCounters,
+  getCacheCounters,
+
+  // In-flight refcounting + pre-build headroom
+  invokeEntryHandler,
+  ensureCacheHeadroom,
+
+  // Capacity model + memory governor
+  computeCapacityFromBudget,
+  MemoryPressure,
+  MemoryPressureLevel,
+  getMemoryPressure,
+  shouldRefuseBuild,
+  startMemoryGovernor,
+  stopMemoryGovernor,
+
+  // Drain-aware build admission
+  getDrainingCount,
+  waitForDrainSettle,
+
   // Clear matching entries
   clearMatchingEntries
 } from './graphile-cache';
diff --git a/graphile/graphile-i18n/src/plugin.ts b/graphile/graphile-i18n/src/plugin.ts
index ebe3ab14a4..81f1a2acad 100644
--- a/graphile/graphile-i18n/src/plugin.ts
+++ b/graphile/graphile-i18n/src/plugin.ts
@@ -74,7 +74,7 @@ export function createI18nPlugin(options: I18nPluginOptions = {}): GraphileConfi
 
   // Closure-scoped state shared between init and field hooks
   let i18nRegistry: Record<string, I18nTableInfo> = {};
-  const localeTypeCache: Record<string, any> = {};
+  let localeTypeCache: Record<string, any> = {};
 
   return {
     name: 'I18nPlugin',
@@ -85,6 +85,7 @@ export function createI18nPlugin(options: I18nPluginOptions = {}): GraphileConfi
         init: {
           callback(_, build) {
             i18nRegistry = {};
+            localeTypeCache = {};
 
             for (const [, codec] of Object.entries(build.input.pgRegistry.pgCodecs)) {
               const c = codec as PgCodecWithAttributes;
@@ -238,10 +239,13 @@ export function createI18nPlugin(options: I18nPluginOptions = {}): GraphileConfi
             .map(f => `coalesce(v."${f.column}", b."${f.column}") as "${f.column}"`)
             .join(', ');
 
+          const baseTableRef = `"${schemaName}"."${baseTable}"`;
+          const translationTableRef = `"${schemaName}"."${translationTable}"`;
+
           // Build the SQL query template
           const sqlQuery = `SELECT v."${langCodeColumn}" AS "lang_code", ${coalescedCols}
-             FROM "${schemaName}"."${baseTable}" b
-             LEFT JOIN "${schemaName}"."${translationTable}" v
+             FROM ${baseTableRef} b
+             LEFT JOIN ${translationTableRef} v
                ON v."${fkColumn}" = b."${pkColumn}"
                AND array_position($2::text[], v."${langCodeColumn}") IS NOT NULL
              WHERE b."${pkColumn}" = $1::${pkType}
@@ -265,18 +269,20 @@ export function createI18nPlugin(options: I18nPluginOptions = {}): GraphileConfi
                   $baseCols[column] = $parent.get(column);
                 }
                 const $withPgClient = (grafastContext() as any).get('withPgClient');
+                const $pgSettings = (grafastContext() as any).get('pgSettings');
                 const $langCodes = (grafastContext() as any).get('langCodes');
 
                 // Combine all inputs into a single step
                 const $input = object({
                   id: $id,
                   withPgClient: $withPgClient,
+                  pgSettings: $pgSettings,
                   langCodes: $langCodes,
                   ...$baseCols,
                 });
 
                 return lambda($input, async (input: any) => {
-                  const { id, withPgClient, langCodes: ctxLangCodes, ...baseCols } = input;
+                  const { id, withPgClient, pgSettings, langCodes: ctxLangCodes, ...baseCols } = input;
                   const langs: string[] = ctxLangCodes ?? defaultLanguages;
 
                   if (!withPgClient || !id) {
@@ -287,7 +293,7 @@ export function createI18nPlugin(options: I18nPluginOptions = {}): GraphileConfi
                     return result;
                   }
 
-                  const row = await withPgClient(null, async (client: any) => {
+                  const row = await withPgClient(pgSettings, async (client: any) => {
                     const { rows } = await client.query(sqlQuery, [id, langs]);
                     return rows[0] ?? null;
                   });
diff --git a/graphile/graphile-llm/src/__tests__/agent-discovery.test.ts b/graphile/graphile-llm/src/__tests__/agent-discovery.test.ts
new file mode 100644
index 0000000000..c0b9e14c7f
--- /dev/null
+++ b/graphile/graphile-llm/src/__tests__/agent-discovery.test.ts
@@ -0,0 +1,148 @@
+/**
+ * Agent discovery tenant-isolation tests (pure, no DB required).
+ *
+ * Verifies the cross-tenant bleed fix: discovery is filtered by the requesting
+ * tenant's database id (resolved from jwt.claims.database_id in pgSettings and
+ * passed as $1), and the per-database cache is keyed by that id — never by
+ * dbname alone — so a shared/pooled instance cannot return another tenant's
+ * agent config.
+ */
+
+import { clearAgentDiscoveryCache, getAgentDiscovery } from '../plugins/agent-discovery-plugin';
+
+// ─── Fake pool ───────────────────────────────────────────────────────────────
+
+interface QueryCall {
+  sql: string;
+  values: unknown[] | undefined;
+}
+
+/**
+ * A fake pg Pool whose `query` scopes rows by the $1 database id — mirroring how
+ * the real (shared) control-plane metaschema tables behave once the WHERE
+ * clause is applied. Records every call for assertions.
+ */
+function makeFakePool(rowsByDatabaseId: Record<string, any>) {
+  const calls: QueryCall[] = [];
+  const pool = {
+    calls,
+    query: async (sql: string, values?: unknown[]) => {
+      calls.push({ sql, values });
+      const id = values?.[0] as string | null;
+      const row = id != null ? rowsByDatabaseId[id] : undefined;
+      return { rows: row ? [row] : [] };
+    }
+  };
+  return pool;
+}
+
+const TENANT_1 = '11111111-1111-1111-1111-111111111111';
+const TENANT_2 = '22222222-2222-2222-2222-222222222222';
+
+const ROWS = {
+  [TENANT_1]: {
+    schema_name: 'tenant1_agent',
+    thread_table_name: 'agent_thread',
+    message_table_name: 'agent_message',
+    task_table_name: 'agent_task'
+  },
+  [TENANT_2]: {
+    schema_name: 'tenant2_agent',
+    thread_table_name: 't2_thread',
+    message_table_name: 't2_message',
+    task_table_name: 't2_task'
+  }
+};
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('getAgentDiscovery — tenant isolation', () => {
+  beforeEach(() => {
+    clearAgentDiscoveryCache();
+  });
+
+  it('filters by the tenant database id from pgSettings, passed as $1', async () => {
+    const pool = makeFakePool(ROWS);
+
+    const result = await getAgentDiscovery(pool as any, 'shared-db', {
+      'jwt.claims.database_id': TENANT_1
+    });
+
+    expect(pool.calls).toHaveLength(1);
+    expect(pool.calls[0].sql).toContain('WHERE s.database_id = $1');
+    expect(pool.calls[0].values).toEqual([TENANT_1]);
+
+    expect(result).not.toBeNull();
+    expect(result!.thread).toEqual({ schemaName: 'tenant1_agent', tableName: 'agent_thread' });
+    expect(result!.message).toEqual({ schemaName: 'tenant1_agent', tableName: 'agent_message' });
+    expect(result!.task).toEqual({ schemaName: 'tenant1_agent', tableName: 'agent_task' });
+  });
+
+  it('does NOT bleed across tenants sharing one instance/dbname', async () => {
+    const pool = makeFakePool(ROWS);
+
+    const t1 = await getAgentDiscovery(pool as any, 'shared-db', {
+      'jwt.claims.database_id': TENANT_1
+    });
+    const t2 = await getAgentDiscovery(pool as any, 'shared-db', {
+      'jwt.claims.database_id': TENANT_2
+    });
+
+    // Each tenant gets its own config despite the same dbname.
+    expect(t1!.thread!.schemaName).toBe('tenant1_agent');
+    expect(t2!.thread!.schemaName).toBe('tenant2_agent');
+
+    // Two distinct database ids ⇒ two separate cache entries ⇒ two queries.
+    expect(pool.calls.map((c) => c.values)).toEqual([[TENANT_1], [TENANT_2]]);
+  });
+
+  it('caches by database id (same id ⇒ a single query)', async () => {
+    const pool = makeFakePool(ROWS);
+
+    const a = await getAgentDiscovery(pool as any, 'shared-db', {
+      'jwt.claims.database_id': TENANT_1
+    });
+    const b = await getAgentDiscovery(pool as any, 'shared-db', {
+      'jwt.claims.database_id': TENANT_1
+    });
+
+    expect(pool.calls).toHaveLength(1);
+    expect(a).toEqual(b);
+  });
+
+  it('fails closed when database id is absent — passes null as $1, keys under <dbname>:nodb', async () => {
+    const pool = makeFakePool(ROWS);
+
+    // No pgSettings at all.
+    const r1 = await getAgentDiscovery(pool as any, 'shared-db');
+    // Empty pgSettings (no jwt.claims.database_id).
+    const r2 = await getAgentDiscovery(pool as any, 'shared-db', {});
+
+    expect(r1).toBeNull();
+    expect(r2).toBeNull();
+
+    // First call queries with null $1; second is served from the ':nodb' cache.
+    expect(pool.calls).toHaveLength(1);
+    expect(pool.calls[0].values).toEqual([null]);
+
+    // A different dbname without an id uses a different ':nodb' key ⇒ new query.
+    await getAgentDiscovery(pool as any, 'other-db');
+    expect(pool.calls).toHaveLength(2);
+  });
+
+  it('caches null (unprovisioned tenant) without re-querying', async () => {
+    // Pool returns no rows for this (valid) tenant id ⇒ discovery is null.
+    const pool = makeFakePool({});
+
+    const first = await getAgentDiscovery(pool as any, 'shared-db', {
+      'jwt.claims.database_id': TENANT_1
+    });
+    const second = await getAgentDiscovery(pool as any, 'shared-db', {
+      'jwt.claims.database_id': TENANT_1
+    });
+
+    expect(first).toBeNull();
+    expect(second).toBeNull();
+    expect(pool.calls).toHaveLength(1);
+  });
+});
diff --git a/graphile/graphile-llm/src/__tests__/rag-unqualified.test.ts b/graphile/graphile-llm/src/__tests__/rag-unqualified.test.ts
new file mode 100644
index 0000000000..d89fa1f17e
--- /dev/null
+++ b/graphile/graphile-llm/src/__tests__/rag-unqualified.test.ts
@@ -0,0 +1,96 @@
+/**
+ * RAG chunk-table qualification tests (pure, no DB / no Ollama required).
+ *
+ * Verifies the generated chunk search SQL references the tenant-data table
+ * schema-qualified when a chunks schema is known, and falls back to a bare
+ * table name only when no schema is available.
+ */
+
+import { buildChunkSearchSql, discoverChunkTables } from '../plugins/rag-plugin';
+import type { ChunkTableInfo } from '../types';
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+function baseChunkTable(overrides: Partial<ChunkTableInfo> = {}): ChunkTableInfo {
+  return {
+    parentCodecName: 'articles',
+    chunksSchema: 'llm_test',
+    chunksTableName: 'articles_chunks',
+    parentFkField: 'parent_id',
+    parentPkField: 'id',
+    embeddingField: 'embedding',
+    contentField: 'content',
+    ...overrides
+  };
+}
+
+function makeBuild() {
+  return {
+    options: {},
+    input: {
+      pgRegistry: {
+        pgCodecs: {
+          articles: {
+            name: 'articles',
+            attributes: { id: {}, title: {} },
+            extensions: {
+              pg: { schemaName: 'llm_test' },
+              tags: {
+                hasChunks: {
+                  chunksTable: 'articles_chunks',
+                  parentFk: 'parent_id',
+                  parentPk: 'id',
+                  embeddingField: 'embedding',
+                  contentField: 'content'
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+
+// ─── buildChunkSearchSql ─────────────────────────────────────────────────────
+
+describe('buildChunkSearchSql — chunk table qualification', () => {
+  it('emits a SCHEMA-QUALIFIED reference by default', () => {
+    const { text } = buildChunkSearchSql(baseChunkTable(), '[1,0,0]', 5, null);
+    expect(text).toContain('FROM "llm_test"."articles_chunks"');
+  });
+
+  it('emits an UNQUALIFIED reference when no schema is known (existing fallback)', () => {
+    const { text } = buildChunkSearchSql(
+      baseChunkTable({ chunksSchema: null }),
+      '[1,0,0]',
+      5,
+      null
+    );
+    expect(text).toContain('FROM "articles_chunks"');
+  });
+
+  it('preserves parameter order/values (no maxDistance)', () => {
+    const { values } = buildChunkSearchSql(baseChunkTable(), '[1,0,0]', 7, null);
+    expect(values).toEqual(['[1,0,0]', 7]);
+  });
+
+  it('preserves parameter order/values (with maxDistance)', () => {
+    const { text, values } = buildChunkSearchSql(baseChunkTable(), '[1,0,0]', 7, 0.4);
+    expect(values).toEqual(['[1,0,0]', 0.4, 7]);
+    expect(text).toContain('LIMIT $3');
+  });
+});
+
+// ─── discoverChunkTables ─────────────────────────────────────────────────────
+
+describe('discoverChunkTables', () => {
+  it('discovers chunk tables and emits schema-qualified SQL', () => {
+    const tables = discoverChunkTables(makeBuild());
+    expect(tables).toHaveLength(1);
+    expect(tables[0].chunksSchema).toBe('llm_test');
+
+    const { text } = buildChunkSearchSql(tables[0], '[1,0,0]', 5, null);
+    expect(text).toContain('FROM "llm_test"."articles_chunks"');
+  });
+});
diff --git a/graphile/graphile-llm/src/plugins/agent-discovery-plugin.ts b/graphile/graphile-llm/src/plugins/agent-discovery-plugin.ts
index ad020c4dc3..735ca173dc 100644
--- a/graphile/graphile-llm/src/plugins/agent-discovery-plugin.ts
+++ b/graphile/graphile-llm/src/plugins/agent-discovery-plugin.ts
@@ -41,6 +41,9 @@ export function clearAgentDiscoveryCache(): void {
 
 // ─── Discovery Query ────────────────────────────────────────────────────────
 
+// Control-plane metaschema_* tables stay fully qualified. The schema row is
+// filtered by the requesting tenant's database id ($1) so a shared/pooled
+// instance never bleeds another tenant's agent config across the join.
 const DISCOVERY_SQL = `
   SELECT
     s.schema_name,
@@ -49,18 +52,31 @@ const DISCOVERY_SQL = `
     acm.task_table_name
   FROM metaschema_modules_public.agent_chat_module acm
   JOIN metaschema_public.schema s ON s.id = acm.schema_id
+  WHERE s.database_id = $1
   LIMIT 1
 `;
 
 /**
  * Look up agent table info for a database, querying the module config table.
- * Results are cached per-database with a 60s TTL.
+ *
+ * The requesting tenant is identified by its database id, resolved from
+ * `jwt.claims.database_id` in the per-request pgSettings — the same way the
+ * billing config cache obtains it (see config-cache.ts / metering-plugin.ts).
+ * The query filters on that id so a shared instance cannot return another
+ * tenant's config. When the id is absent we fail closed (no discovery) and
+ * cache under a `<dbname>:nodb` key to avoid poisoning a real tenant's entry.
+ *
+ * Results are cached per database id with a 60s TTL.
  */
 export async function getAgentDiscovery(
   pool: Pool,
-  dbname: string
+  dbname: string,
+  pgSettings?: Record<string, string> | null
 ): Promise<AgentDiscovery | null> {
-  const cached = agentDiscoveryCache.get(dbname);
+  const databaseId = pgSettings?.['jwt.claims.database_id'] ?? null;
+  const cacheKey = databaseId ?? `${dbname}:nodb`;
+
+  const cached = agentDiscoveryCache.get(cacheKey);
   if (cached !== undefined) {
     return cached;
   }
@@ -68,7 +84,7 @@ export async function getAgentDiscovery(
   let discovery: AgentDiscovery | null = null;
 
   try {
-    const { rows } = await pool.query(DISCOVERY_SQL);
+    const { rows } = await pool.query(DISCOVERY_SQL, [databaseId]);
 
     if (rows.length > 0) {
       const row = rows[0];
@@ -90,6 +106,6 @@ export async function getAgentDiscovery(
     // Module table doesn't exist in this database — not provisioned
   }
 
-  agentDiscoveryCache.set(dbname, discovery);
+  agentDiscoveryCache.set(cacheKey, discovery);
   return discovery;
 }
diff --git a/graphile/graphile-llm/src/plugins/rag-plugin.ts b/graphile/graphile-llm/src/plugins/rag-plugin.ts
index 3c1a3e15cf..d60c4f3715 100644
--- a/graphile/graphile-llm/src/plugins/rag-plugin.ts
+++ b/graphile/graphile-llm/src/plugins/rag-plugin.ts
@@ -86,8 +86,10 @@ function parseHasChunksTag(raw: any, codec: any): ChunkTableInfo | null {
 
 /**
  * Discover all chunk-aware tables from the pgRegistry.
+ *
+ * Exported for unit testing.
  */
-function discoverChunkTables(build: any): ChunkTableInfo[] {
+export function discoverChunkTables(build: any): ChunkTableInfo[] {
   const chunkTables: ChunkTableInfo[] = [];
   const pgRegistry = build.input?.pgRegistry ?? build.pgRegistry;
   if (!pgRegistry) return chunkTables;
@@ -111,17 +113,19 @@ function discoverChunkTables(build: any): ChunkTableInfo[] {
 
 /**
  * Build a SQL query string to search a chunks table for similar embeddings.
+ *
+ * Exported for unit testing.
  */
-function buildChunkSearchSql(
+export function buildChunkSearchSql(
   table: ChunkTableInfo,
   vectorString: string,
   limit: number,
   maxDistance: number | null
 ): { text: string; values: any[] } {
-  const schema = table.chunksSchema;
-  const qualifiedTable = schema
-    ? `"${schema}"."${table.chunksTableName}"`
-    : `"${table.chunksTableName}"`;
+  // Keep the schema-qualified reference when a schema is known.
+  const qualifiedTable = !table.chunksSchema
+    ? `"${table.chunksTableName}"`
+    : `"${table.chunksSchema}"."${table.chunksTableName}"`;
 
   const embeddingCol = `"${table.embeddingField}"`;
   const contentCol = `"${table.contentField}"`;
diff --git a/graphile/graphile-presigned-url-plugin/__tests__/storage-module-cache.test.ts b/graphile/graphile-presigned-url-plugin/__tests__/storage-module-cache.test.ts
new file mode 100644
index 0000000000..54ed68236d
--- /dev/null
+++ b/graphile/graphile-presigned-url-plugin/__tests__/storage-module-cache.test.ts
@@ -0,0 +1,209 @@
+/**
+ * Unit tests for resolveStorageConfigFromCodec.
+ *
+ * These are pure (no DB) tests covering both the single-tenant path (exact
+ * physical schema match) and the blueprint-pooling path, where the codec's
+ * build-time schema belongs to the REPRESENTATIVE tenant but the request's
+ * configs carry a DIFFERENT tenant's actual (differently-hashed) schema. In
+ * that case the resolver must fall back to matching on the LOGICAL schema
+ * name (the tenant hash prefix stripped from both sides).
+ */
+
+import { resolveStorageConfigFromCodec } from '../src/storage-module-cache';
+import type { StorageModuleConfig } from '../src/types';
+
+// --- Fixtures -------------------------------------------------------------
+
+// Two real-shaped hashed tenant schemas that share the SAME logical suffix
+// (`storage-public`). Under pooling, the shared instance is built against the
+// representative tenant's schema, while requests route to other tenants.
+const REPRESENTATIVE_SCHEMA = 'marketplace-db-tenant1-5e6b13b2-storage-public';
+const TENANT_SCHEMA = 'marketplace-db-tenant2-35a03232-storage-public';
+
+function makeConfig(
+  overrides: Partial<StorageModuleConfig> &
+    Pick<StorageModuleConfig, 'id' | 'schemaName' | 'bucketsTableName' | 'filesTableName'>,
+): StorageModuleConfig {
+  return {
+    bucketsQualifiedName: `"${overrides.schemaName}"."${overrides.bucketsTableName}"`,
+    filesQualifiedName: `"${overrides.schemaName}"."${overrides.filesTableName}"`,
+    scope: 'app',
+    entityTableId: null,
+    entityQualifiedName: null,
+    endpoint: null,
+    publicUrlPrefix: null,
+    provider: null,
+    allowedOrigins: null,
+    uploadUrlExpirySeconds: 900,
+    downloadUrlExpirySeconds: 3600,
+    defaultMaxFileSize: 200 * 1024 * 1024,
+    maxFilenameLength: 1024,
+    cacheTtlSeconds: 3600,
+    hasPathShares: false,
+    maxBulkFiles: 100,
+    maxBulkTotalSize: 1073741824,
+    ...overrides,
+  };
+}
+
+function makeCodec(schemaName: string | undefined, name: string | undefined) {
+  return { name: name as string, extensions: { pg: { schemaName, name } } };
+}
+
+// --- Tests ----------------------------------------------------------------
+
+describe('resolveStorageConfigFromCodec', () => {
+  describe('single-tenant (exact physical schema match)', () => {
+    it('matches a files codec by exact schema + files table name', () => {
+      const config = makeConfig({
+        id: 'sm-1',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec(TENANT_SCHEMA, 'app_files');
+
+      expect(resolveStorageConfigFromCodec(codec, [config])).toBe(config);
+    });
+
+    it('matches a buckets codec by exact schema + buckets table name', () => {
+      const config = makeConfig({
+        id: 'sm-1',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec(TENANT_SCHEMA, 'app_buckets');
+
+      expect(resolveStorageConfigFromCodec(codec, [config])).toBe(config);
+    });
+
+    it('matches plain (non-hashed) schemas exactly, unaffected by hash stripping', () => {
+      const config = makeConfig({
+        id: 'sm-1',
+        schemaName: 'app_public',
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec('app_public', 'app_files');
+
+      expect(resolveStorageConfigFromCodec(codec, [config])).toBe(config);
+    });
+  });
+
+  describe('blueprint pooling (logical schema match across tenants)', () => {
+    it('matches a files codec built for the representative tenant against another tenant config', () => {
+      // Build-time codec: representative tenant. Request config: a DIFFERENT tenant.
+      const tenantConfig = makeConfig({
+        id: 'sm-tenant2',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec(REPRESENTATIVE_SCHEMA, 'app_files');
+
+      // Physical schemas differ; logical suffix (`storage-public`) is shared.
+      expect(REPRESENTATIVE_SCHEMA).not.toEqual(TENANT_SCHEMA);
+      expect(resolveStorageConfigFromCodec(codec, [tenantConfig])).toBe(tenantConfig);
+    });
+
+    it('matches a buckets codec built for the representative tenant against another tenant config', () => {
+      const tenantConfig = makeConfig({
+        id: 'sm-tenant2',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec(REPRESENTATIVE_SCHEMA, 'app_buckets');
+
+      expect(resolveStorageConfigFromCodec(codec, [tenantConfig])).toBe(tenantConfig);
+    });
+
+    it('does NOT match when the logical schema suffix differs', () => {
+      // A codec whose logical schema is `analytics-public` must not resolve to a
+      // `storage-public` config even though both are hashed tenant schemas.
+      const tenantConfig = makeConfig({
+        id: 'sm-tenant2',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec('marketplace-db-tenant1-5e6b13b2-analytics-public', 'app_files');
+
+      expect(resolveStorageConfigFromCodec(codec, [tenantConfig])).toBeNull();
+    });
+  });
+
+  describe('exact-physical priority', () => {
+    it('prefers an exact physical match over a logical-only match', () => {
+      const exactConfig = makeConfig({
+        id: 'sm-exact',
+        schemaName: REPRESENTATIVE_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const logicalOnlyConfig = makeConfig({
+        id: 'sm-logical',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec(REPRESENTATIVE_SCHEMA, 'app_files');
+
+      // exactConfig listed AFTER the logical-only one to prove priority is by
+      // match quality, not array order.
+      const result = resolveStorageConfigFromCodec(codec, [logicalOnlyConfig, exactConfig]);
+      expect(result).toBe(exactConfig);
+    });
+  });
+
+  describe('non-matches and guards', () => {
+    it('returns null when the table name matches nothing', () => {
+      const config = makeConfig({
+        id: 'sm-1',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec(REPRESENTATIVE_SCHEMA, 'some_unrelated_table');
+
+      expect(resolveStorageConfigFromCodec(codec, [config])).toBeNull();
+    });
+
+    it('returns null when the codec has no schemaName', () => {
+      const config = makeConfig({
+        id: 'sm-1',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = makeCodec(undefined, 'app_files');
+
+      expect(resolveStorageConfigFromCodec(codec, [config])).toBeNull();
+    });
+
+    it('returns null when the codec has no resolvable table name', () => {
+      const config = makeConfig({
+        id: 'sm-1',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = { name: undefined as unknown as string, extensions: { pg: { schemaName: REPRESENTATIVE_SCHEMA } } };
+
+      expect(resolveStorageConfigFromCodec(codec, [config])).toBeNull();
+    });
+
+    it('falls back to codec.name for the table name when extensions.pg.name is absent', () => {
+      const config = makeConfig({
+        id: 'sm-1',
+        schemaName: TENANT_SCHEMA,
+        bucketsTableName: 'app_buckets',
+        filesTableName: 'app_files',
+      });
+      const codec = { name: 'app_files', extensions: { pg: { schemaName: REPRESENTATIVE_SCHEMA } } };
+
+      expect(resolveStorageConfigFromCodec(codec, [config])).toBe(config);
+    });
+  });
+});
diff --git a/graphile/graphile-presigned-url-plugin/src/storage-module-cache.ts b/graphile/graphile-presigned-url-plugin/src/storage-module-cache.ts
index 6ea403fbb5..5cf993558e 100644
--- a/graphile/graphile-presigned-url-plugin/src/storage-module-cache.ts
+++ b/graphile/graphile-presigned-url-plugin/src/storage-module-cache.ts
@@ -354,12 +354,46 @@ export async function loadAllStorageModules(
   return configs;
 }
 
+/**
+ * Strip a tenant hash prefix from a physical schema name, returning the
+ * logical schema name.
+ *
+ * Hashed multi-tenant schemas are named like
+ * `marketplace-db-tenant1-5e6b13b2-app-public`, where `-5e6b13b2-` is an
+ * 8-hex-char tenant hash separating the tenant prefix from the logical schema
+ * suffix (`app-public`). This removes everything up to and including the first
+ * such hash segment. If no hash segment is present (e.g. a plain schema like
+ * `app_public` or a control-plane schema like `metaschema_public`), the name
+ * is returned unchanged.
+ *
+ * (Duplicated locally rather than imported to avoid a cross-package dependency
+ * for a one-line helper.)
+ */
+function stripSchemaHashPrefix(name: string): string {
+  const match = /-[0-9a-f]{8}-/.exec(name);
+  return match ? name.slice(match.index + match[0].length) : name;
+}
+
 /**
  * Resolve the storage module config from a PostGraphile pgCodec.
  *
  * Matches the codec's schema + table name against cached storage modules.
  * Works for both files codecs (@storageFiles) and buckets codecs (@storageBuckets).
  *
+ * Matching is two-tier:
+ *   1. Exact physical schema match — used for single-tenant / non-pooled
+ *      instances where the codec's build-time schema equals the request
+ *      tenant's actual schema. Keeps existing behavior unchanged.
+ *   2. Logical schema match — strip the tenant hash prefix from BOTH the
+ *      codec's schema and each config's schema before comparing. Under
+ *      blueprint pooling a single shared instance serves every tenant of a
+ *      given schema-shape, so the codec's build-time `schemaName` belongs to
+ *      the representative tenant while `allConfigs` carry the request tenant's
+ *      actual (differently-hashed) schema. Both share the same logical suffix
+ *      (e.g. `app-public`). Safe because `allConfigs` is already filtered to a
+ *      single databaseId, so (tableName, logicalSchema) uniquely identifies a
+ *      module.
+ *
  * @param pgCodec - The PostGraphile codec (has extensions.pg.schemaName, name)
  * @param allConfigs - All storage module configs for this database
  * @returns The matching StorageModuleConfig or null
@@ -373,10 +407,24 @@ export function resolveStorageConfigFromCodec(
 
   if (!schemaName || !tableName) return null;
 
-  return allConfigs.find((c) =>
+  // Priority 1: exact physical schema match (non-pooled / single-tenant).
+  const exact = allConfigs.find((c) =>
     (c.filesTableName === tableName && c.schemaName === schemaName) ||
     (c.bucketsTableName === tableName && c.schemaName === schemaName),
-  ) || null;
+  );
+  if (exact) return exact;
+
+  // Priority 2: logical schema match (blueprint pooling — the codec's
+  // build-time schema belongs to the representative tenant; strip the tenant
+  // hash from both sides so the shared logical suffix lines up).
+  const logicalSchema = stripSchemaHashPrefix(schemaName);
+  return allConfigs.find((c) => {
+    const configLogicalSchema = stripSchemaHashPrefix(c.schemaName);
+    return (
+      (c.filesTableName === tableName && configLogicalSchema === logicalSchema) ||
+      (c.bucketsTableName === tableName && configLogicalSchema === logicalSchema)
+    );
+  }) || null;
 }
 
 // --- Bucket metadata cache ---
diff --git a/graphile/graphile-search/src/__tests__/search-config.test.ts b/graphile/graphile-search/src/__tests__/search-config.test.ts
index 1ead0f6b6b..12c142b4d8 100644
--- a/graphile/graphile-search/src/__tests__/search-config.test.ts
+++ b/graphile/graphile-search/src/__tests__/search-config.test.ts
@@ -423,3 +423,104 @@ describe('VectorNearbyInput includeChunks field (Phase E)', () => {
     expect(fields.includeChunks.description).toContain('chunks');
   });
 });
+
+// ─── Adapter SQL qualification ────────────────────────────────────────────────
+//
+// Tenant-data SQL (bm25 index names, chunk table references) is always emitted
+// fully schema-qualified. Tenant routing happens elsewhere (the rewriting pool
+// maps canonical→tenant schemas at query time), so the adapters do not
+// special-case pooled instances.
+
+describe('adapter SQL qualification', () => {
+  // Mock sql object that mimics pg-sql2 behavior (same shape as above).
+  const mockSql = {
+    identifier: (name: string) => `"${name}"`,
+    value: (val: any) => `'${val}'`,
+    literal: (val: any) => `'${val}'`,
+    raw: (s: string) => s,
+    fragment: (strings: TemplateStringsArray, ...values: any[]) => {
+      let result = '';
+      strings.forEach((str, i) => {
+        result += str;
+        if (i < values.length) result += String(values[i]);
+      });
+      return result;
+    },
+    join: (parts: any[], sep: string) => parts.join(sep),
+    parens: (expr: any) => `(${expr})`,
+  };
+  const sql = Object.assign(
+    (strings: TemplateStringsArray, ...values: any[]) => {
+      let result = '';
+      strings.forEach((str: string, i: number) => {
+        result += str;
+        if (i < values.length) result += String(values[i]);
+      });
+      return result;
+    },
+    mockSql,
+  );
+
+  // ── bm25: index name passed to to_bm25query ──
+  describe('bm25 adapter — index name', () => {
+    const adapter = createBm25Adapter();
+    const bm25Column = {
+      attributeName: 'body',
+      adapterData: {
+        bm25Index: {
+          schemaName: 'app_private',
+          tableName: 'documents',
+          columnName: 'body',
+          indexName: 'documents_body_bm25_idx',
+        },
+      },
+    };
+
+    it('emits the schema-qualified index name', () => {
+      const result = adapter.buildFilterApply(
+        sql,
+        'tbl' as any,
+        bm25Column,
+        { query: 'hello' },
+        {},
+      );
+
+      expect(result).not.toBeNull();
+      const scoreStr = String(result!.scoreExpression);
+      // Default behavior: fully qualified "schema"."index"
+      expect(scoreStr).toContain('"app_private"."documents_body_bm25_idx"');
+    });
+  });
+
+  // ── pgvector: chunk table reference ──
+  describe('pgvector adapter — chunk table reference', () => {
+    const adapter = createPgvectorAdapter();
+    const chunkColumn = {
+      attributeName: 'embedding',
+      adapterData: {
+        chunksInfo: {
+          chunksSchema: 'app_private',
+          chunksTableName: 'doc_chunks',
+          parentFkField: 'document_id',
+          parentPkField: 'row_id',
+          embeddingField: 'vec',
+        },
+      },
+    };
+
+    it('emits the schema-qualified chunk table', () => {
+      const result = adapter.buildFilterApply(
+        sql,
+        'tbl' as any,
+        chunkColumn,
+        { vector: [1, 0, 0], metric: 'COSINE' },
+        {},
+      );
+
+      expect(result).not.toBeNull();
+      const scoreStr = String(result!.scoreExpression);
+      expect(scoreStr).toContain('"app_private"."doc_chunks"');
+      expect(scoreStr).toContain('LEAST');
+    });
+  });
+});
diff --git a/graphile/graphile-search/src/adapters/bm25.ts b/graphile/graphile-search/src/adapters/bm25.ts
index 26ea207f38..d2bb76f7a4 100644
--- a/graphile/graphile-search/src/adapters/bm25.ts
+++ b/graphile/graphile-search/src/adapters/bm25.ts
@@ -180,9 +180,11 @@ export function createBm25Adapter(
       const bm25Index = columnData.bm25Index;
       const columnExpr = sql`${alias}.${sql.identifier(column.attributeName)}`;
 
-      // Use quoteQualifiedIdentifier to produce the qualified index name
-      const qualifiedIndexName = `"${bm25Index.schemaName}"."${bm25Index.indexName}"`;
-      const bm25queryExpr = sql`to_bm25query(${sql.value(query)}, ${sql.value(qualifiedIndexName)})`;
+      // The store lookup (getBm25IndexForAttribute) keys off the build-time
+      // codec schema — correct, because the store was populated by the same
+      // representative gather.
+      const indexNameArg = `"${bm25Index.schemaName}"."${bm25Index.indexName}"`;
+      const bm25queryExpr = sql`to_bm25query(${sql.value(query)}, ${sql.value(indexNameArg)})`;
       const scoreExpr = sql`(${columnExpr} <@> ${bm25queryExpr})`;
 
       // Check for chunk-aware querying
diff --git a/graphile/graphile-search/src/codecs/bm25-codec.ts b/graphile/graphile-search/src/codecs/bm25-codec.ts
index 117ca88340..5fd82bce32 100644
--- a/graphile/graphile-search/src/codecs/bm25-codec.ts
+++ b/graphile/graphile-search/src/codecs/bm25-codec.ts
@@ -36,6 +36,15 @@ export interface Bm25IndexInfo {
  *
  * Key: "schemaName.tableName.columnName"
  * Value: Bm25IndexInfo
+ *
+ * NOTE (blueprint pooling): this store is process-global and is cleared +
+ * repopulated per introspection run (see pgIntrospection_introspection).
+ * Concurrent gathers are serialized by the server's build semaphore, so a
+ * single global store is tolerated for now. Under blueprint pooling the store
+ * is keyed by the representative tenant's schema; the BM25 adapter reads the
+ * index NAME from these entries and always passes the schema-qualified index
+ * name to to_bm25query. Under pooling the rewriting pool maps canonical→tenant
+ * schemas at query time, resolving the correct tenant index.
  */
 export const bm25IndexStore = new Map<string, Bm25IndexInfo>();
 
diff --git a/graphile/graphile-settings/src/plugins/meta-schema/cache.ts b/graphile/graphile-settings/src/plugins/meta-schema/cache.ts
index 3e9f909b7a..916d6712b0 100644
--- a/graphile/graphile-settings/src/plugins/meta-schema/cache.ts
+++ b/graphile/graphile-settings/src/plugins/meta-schema/cache.ts
@@ -1,5 +1,41 @@
 import type { TableMeta } from './types';
 
+/**
+ * Per-build table metadata, keyed by the PostGraphile `build` object.
+ *
+ * The server constructs multiple PostGraphile schemas concurrently in a single
+ * process, so the `init` and `GraphQLObjectType_fields` hooks of different
+ * builds interleave. Keying the collected metadata on the build object (instead
+ * of a single shared array) guarantees each schema's `_meta` field serves its
+ * OWN tables and never bleeds another concurrent build's data.
+ *
+ * A WeakMap is used (rather than a property on the build) because graphile-build
+ * freezes the build object before the `init` hook runs, so it cannot be mutated
+ * with an own property. The WeakMap also lets entries be garbage-collected once
+ * a build is discarded.
+ */
+const tablesMetaByBuild = new WeakMap<object, TableMeta[]>();
+
+export function setTablesMetaForBuild(build: object, tablesMeta: TableMeta[]): void {
+  tablesMetaByBuild.set(build, tablesMeta);
+}
+
+export function getTablesMetaForBuild(build: object): TableMeta[] {
+  return tablesMetaByBuild.get(build) ?? [];
+}
+
+/**
+ * Flat "last build wins" mirror of the most recently collected table metadata.
+ *
+ * Retained ONLY for out-of-process codegen consumers — graphile-schema's
+ * `buildIntrospectionJSON` and graphql/codegen's `DatabaseSchemaSource` — which
+ * read this (re-exported as `_cachedTablesMeta`) as a side-effect AFTER a single
+ * `buildSchemaSDL()` call and have no reference to the `build` object. Those
+ * paths build one schema at a time, so last-write-wins is safe for them.
+ *
+ * Do NOT read this from the concurrent schema-serving path (the `_meta` field):
+ * use getTablesMetaForBuild(build) instead, or concurrent builds will bleed.
+ */
 export let cachedTablesMeta: TableMeta[] = [];
 
 export function getCachedTablesMeta(): TableMeta[] {
diff --git a/graphile/graphile-settings/src/plugins/meta-schema/plugin.ts b/graphile/graphile-settings/src/plugins/meta-schema/plugin.ts
index 2144c323fc..11d66ed0e7 100644
--- a/graphile/graphile-settings/src/plugins/meta-schema/plugin.ts
+++ b/graphile/graphile-settings/src/plugins/meta-schema/plugin.ts
@@ -1,5 +1,9 @@
 import type { GraphileConfig } from 'graphile-config';
-import { getCachedTablesMeta, setCachedTablesMeta } from './cache';
+import {
+  getTablesMetaForBuild,
+  setCachedTablesMeta,
+  setTablesMetaForBuild,
+} from './cache';
 import { extendQueryWithMetaField } from './graphql-meta-field';
 import { collectTablesMeta } from './table-meta-builder';
 import type { MetaBuild } from './types';
@@ -18,16 +22,21 @@ export const MetaSchemaPlugin: GraphileConfig.Plugin = {
     hooks: {
       init(input, rawBuild) {
         const build = rawBuild as unknown as MetaBuild;
-        setCachedTablesMeta(collectTablesMeta(build));
+        const tablesMeta = collectTablesMeta(build);
+        // Keyed by this build so the _meta field resolver reads its own tables,
+        // even when other builds run concurrently in the same process.
+        setTablesMetaForBuild(rawBuild, tablesMeta);
+        // Flat mirror for out-of-process codegen consumers (see cache.ts).
+        setCachedTablesMeta(tablesMeta);
         return input;
       },
 
-      GraphQLObjectType_fields(rawFields, _rawBuild, rawContext) {
+      GraphQLObjectType_fields(rawFields, rawBuild, rawContext) {
         const context = rawContext as unknown as QueryTypeContext;
         if (context.Self?.name !== 'Query') return rawFields;
         return extendQueryWithMetaField(
           rawFields as unknown as Record<string, unknown>,
-          getCachedTablesMeta(),
+          getTablesMetaForBuild(rawBuild),
         ) as typeof rawFields;
       },
     },
diff --git a/graphile/graphile-settings/src/plugins/meta-schema/table-meta-builder.ts b/graphile/graphile-settings/src/plugins/meta-schema/table-meta-builder.ts
index 0b98fccb26..e71ffb7375 100644
--- a/graphile/graphile-settings/src/plugins/meta-schema/table-meta-builder.ts
+++ b/graphile/graphile-settings/src/plugins/meta-schema/table-meta-builder.ts
@@ -115,11 +115,28 @@ function buildTableMeta(
   };
 }
 
+/**
+ * Strip the tenant hash prefix (`<dashed-dbname>-<8hex>-`) from a physical
+ * schema name, returning the logical name; names without a hash segment are
+ * returned unchanged. Local duplicate of the server-side helper to avoid a
+ * cross-package dependency.
+ */
+function stripSchemaHashPrefix(name: string): string {
+  const match = /-[0-9a-f]{8}-/.exec(name);
+  if (!match) return name;
+  return name.slice(match.index + match[0].length);
+}
+
 export function collectTablesMeta(build: MetaBuild): TableMeta[] {
   const configuredSchemas = getConfiguredSchemas(build);
   const context = createBuildContext(build);
   const seenCodecs = new Set<PgCodec>();
   const tablesMeta: TableMeta[] = [];
+  // Shared (pooled) instances serve many tenants: reporting the build-time
+  // PHYSICAL schema name would leak the representative tenant's hashed schema
+  // identifier to every other tenant via _meta. When schema.constructivePooled
+  // is set, report the logical (hash-stripped) name instead.
+  const pooled = !!(build.options as any)?.constructivePooled;
 
   for (const resource of Object.values(build.input.pgRegistry.pgResources || {})) {
     if (!isTableResource(resource)) continue;
@@ -137,7 +154,9 @@ export function collectTablesMeta(build: MetaBuild): TableMeta[] {
       continue;
     }
 
-    tablesMeta.push(buildTableMeta(resource, schemaName, context));
+    tablesMeta.push(
+      buildTableMeta(resource, pooled ? stripSchemaHashPrefix(schemaName) : schemaName, context)
+    );
   }
 
   return tablesMeta;
diff --git a/graphql/server/package.json b/graphql/server/package.json
index dbf1da23d4..96d45f7bf6 100644
--- a/graphql/server/package.json
+++ b/graphql/server/package.json
@@ -78,6 +78,7 @@
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.1052.0",
+    "@dataplan/pg": "1.0.3",
     "@types/cookie-parser": "^1.4.10",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.6",
@@ -88,6 +89,7 @@
     "graphile-test": "workspace:*",
     "makage": "^0.3.0",
     "nodemon": "^3.1.14",
+    "pg-introspection": "1.0.1",
     "ts-node": "^10.9.2"
   }
 }
diff --git a/graphql/server/src/diagnostics/__tests__/metrics-sampler.test.ts b/graphql/server/src/diagnostics/__tests__/metrics-sampler.test.ts
new file mode 100644
index 0000000000..79c8cfadc2
--- /dev/null
+++ b/graphql/server/src/diagnostics/__tests__/metrics-sampler.test.ts
@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { collectMetricsSample, startMetricsSampler } from '../metrics-sampler';
+
+const originalEnv = { ...process.env };
+
+const tmpFile = (): string =>
+  path.join(os.tmpdir(), `metrics-sampler-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.jsonl`);
+
+const waitForFileContent = async (file: string, timeoutMs = 2_000): Promise<string> => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const content = await fs.promises.readFile(file, 'utf8');
+      if (content.trim().length > 0) {
+        return content;
+      }
+    } catch {
+      // file not created yet
+    }
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  throw new Error(`metrics file ${file} never received content`);
+};
+
+afterEach(() => {
+  process.env = { ...originalEnv };
+});
+
+describe('collectMetricsSample', () => {
+  it('produces a well-formed, JSON-serializable sample', () => {
+    const sample = collectMetricsSample();
+
+    expect(typeof sample.ts).toBe('string');
+    expect(Number.isNaN(Date.parse(sample.ts))).toBe(false);
+    expect(typeof sample.rss).toBe('number');
+    expect(typeof sample.heapUsed).toBe('number');
+    expect(typeof sample.heapTotal).toBe('number');
+    expect(typeof sample.external).toBe('number');
+    expect(typeof sample.heap_size_limit).toBe('number');
+    expect(typeof sample.cache.size).toBe('number');
+    expect(typeof sample.cache.keys).toBe('number');
+    // counters merge cache counters + graphile counters + build queue depth
+    expect(typeof sample.counters.disposals).toBe('number');
+    expect(typeof sample.counters.evictions.lru).toBe('number');
+    expect(typeof sample.counters.builds).toBe('number');
+    expect(typeof sample.counters.poolingAttaches).toBe('number');
+    expect(typeof sample.counters.buildQueueDepth).toBe('number');
+    expect(typeof sample.counters.rewritePool.rewrittenQueries).toBe('number');
+    expect(typeof sample.counters.introspectionFilter.swaps).toBe('number');
+    expect(typeof sample.counters.introspectionFilter.discoveries).toBe('number');
+    expect(typeof sample.gc).toBe('object');
+
+    // Round-trips through JSON without loss.
+    expect(() => JSON.parse(JSON.stringify(sample))).not.toThrow();
+  });
+});
+
+describe('startMetricsSampler (disabled)', () => {
+  it('returns null and writes nothing when GRAPHILE_DEBUG_METRICS is unset', async () => {
+    delete process.env.GRAPHILE_DEBUG_METRICS;
+    const file = tmpFile();
+    process.env.GRAPHILE_DEBUG_METRICS_FILE = file;
+
+    const handle = startMetricsSampler();
+    expect(handle).toBeNull();
+
+    await new Promise((resolve) => setTimeout(resolve, 60));
+    expect(fs.existsSync(file)).toBe(false);
+  });
+
+  it('returns null when GRAPHILE_DEBUG_METRICS is a falsy string', () => {
+    process.env.GRAPHILE_DEBUG_METRICS = '0';
+    expect(startMetricsSampler()).toBeNull();
+    process.env.GRAPHILE_DEBUG_METRICS = 'false';
+    expect(startMetricsSampler()).toBeNull();
+  });
+});
+
+describe('startMetricsSampler (enabled)', () => {
+  it("writes a parseable JSON line to the configured file when enabled ('1')", async () => {
+    const file = tmpFile();
+    process.env.GRAPHILE_DEBUG_METRICS = '1';
+    process.env.GRAPHILE_DEBUG_METRICS_FILE = file;
+    process.env.GRAPHILE_DEBUG_METRICS_INTERVAL_MS = '50';
+
+    const handle = startMetricsSampler();
+    expect(handle).not.toBeNull();
+
+    try {
+      const content = await waitForFileContent(file);
+      const firstLine = content.trim().split('\n')[0];
+      const parsed = JSON.parse(firstLine);
+
+      expect(typeof parsed.ts).toBe('string');
+      expect(typeof parsed.rss).toBe('number');
+      expect(typeof parsed.heap_size_limit).toBe('number');
+      expect(parsed.cache).toBeDefined();
+      expect(typeof parsed.counters.disposals).toBe('number');
+      expect(typeof parsed.counters.buildQueueDepth).toBe('number');
+      expect(parsed.gc).toBeDefined();
+    } finally {
+      handle?.stop();
+      await fs.promises.rm(file, { force: true });
+    }
+  });
+
+  it("also treats 'true' as enabled", async () => {
+    const file = tmpFile();
+    process.env.GRAPHILE_DEBUG_METRICS = 'true';
+    process.env.GRAPHILE_DEBUG_METRICS_FILE = file;
+    process.env.GRAPHILE_DEBUG_METRICS_INTERVAL_MS = '50';
+
+    const handle = startMetricsSampler();
+    expect(handle).not.toBeNull();
+
+    try {
+      const content = await waitForFileContent(file);
+      expect(() => JSON.parse(content.trim().split('\n')[0])).not.toThrow();
+    } finally {
+      handle?.stop();
+      await fs.promises.rm(file, { force: true });
+    }
+  });
+});
diff --git a/graphql/server/src/diagnostics/connection-error-guard.ts b/graphql/server/src/diagnostics/connection-error-guard.ts
new file mode 100644
index 0000000000..2a846730ce
--- /dev/null
+++ b/graphql/server/src/diagnostics/connection-error-guard.ts
@@ -0,0 +1,97 @@
+import { Logger } from '@pgpmjs/logger';
+
+const log = new Logger('connection-guard');
+
+/**
+ * Process-level guard for connection-class failures.
+ *
+ * A multi-tenant server holds many long-lived PostgreSQL connections (service
+ * pools, LISTEN/NOTIFY, introspection checkouts). When PostgreSQL restarts or
+ * crash-recovers (failover, OOM-killed backend, admin restart), every one of
+ * those sockets dies at once. Most owners handle their own errors (pg-cache
+ * pools, the schema listener), but a checkout that is mid-query when the
+ * server goes away can surface as an unhandled 'error' event on a raw pg
+ * Client — which kills the WHOLE process, turning a ~15s PostgreSQL recovery
+ * into a full outage for every tenant (observed live during scale validation:
+ * an introspection backend was OOM-killed, PG crash-recovered, and the node
+ * process exited on the orphaned client error).
+ *
+ * This guard absorbs ONLY connection-class errors (logged, counted); anything
+ * else preserves fatal semantics via process.exit(1). Pools reconnect on the
+ * next checkout, so the correct behavior after PG recovery is a brief burst
+ * of 5xx followed by self-healing — not process death.
+ *
+ * Disable with GRAPHILE_CONNECTION_GUARD=0.
+ */
+const CONN_ERROR_CODES = new Set([
+  '57P01', // admin_shutdown (pg_terminate_backend / restart)
+  '57P02', // crash_shutdown
+  '57P03', // cannot_connect_now (recovery in progress)
+  '08006', // connection_failure
+  '08003', // connection_does_not_exist
+  '53300', // too_many_connections
+  'ECONNRESET',
+  'ECONNREFUSED',
+  'EPIPE'
+]);
+
+const CONN_ERROR_RE =
+  /connection terminated|terminating connection|server closed the connection|connection ended|client has encountered a connection error/i;
+
+export const isConnectionClassError = (err: unknown): boolean => {
+  if (!(err instanceof Error)) return false;
+  const code = (err as Error & { code?: string }).code;
+  if (code && CONN_ERROR_CODES.has(code)) return true;
+  return CONN_ERROR_RE.test(err.message || '');
+};
+
+export interface ConnectionErrorGuardCounters {
+  absorbedExceptions: number;
+  absorbedRejections: number;
+}
+
+const counters: ConnectionErrorGuardCounters = {
+  absorbedExceptions: 0,
+  absorbedRejections: 0
+};
+
+export const getConnectionErrorGuardCounters = (): ConnectionErrorGuardCounters => ({ ...counters });
+
+let installed = false;
+
+export function installConnectionErrorGuard(): void {
+  if (installed) return;
+  if (process.env.GRAPHILE_CONNECTION_GUARD === '0') return;
+  installed = true;
+
+  process.on('uncaughtException', (err) => {
+    if (isConnectionClassError(err)) {
+      counters.absorbedExceptions++;
+      log.error(
+        `Absorbed connection-class exception (PG restart/failover?): ${(err as Error).message} ` +
+          `[absorbed=${counters.absorbedExceptions}] — pools reconnect on next checkout`
+      );
+      return;
+    }
+    // Preserve fatal semantics for everything else.
+    // eslint-disable-next-line no-console
+    console.error('Uncaught exception (fatal):', err);
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason) => {
+    if (isConnectionClassError(reason)) {
+      counters.absorbedRejections++;
+      log.error(
+        `Absorbed connection-class rejection (PG restart/failover?): ${(reason as Error).message} ` +
+          `[absorbed=${counters.absorbedRejections}]`
+      );
+      return;
+    }
+    // eslint-disable-next-line no-console
+    console.error('Unhandled rejection (fatal):', reason);
+    process.exit(1);
+  });
+
+  log.info('connection-error guard installed (disable with GRAPHILE_CONNECTION_GUARD=0)');
+}
diff --git a/graphql/server/src/diagnostics/metrics-sampler.ts b/graphql/server/src/diagnostics/metrics-sampler.ts
new file mode 100644
index 0000000000..dceab46552
--- /dev/null
+++ b/graphql/server/src/diagnostics/metrics-sampler.ts
@@ -0,0 +1,219 @@
+import fs from 'node:fs';
+import { constants as perfConstants, PerformanceObserver } from 'node:perf_hooks';
+import v8 from 'node:v8';
+import { Logger } from '@pgpmjs/logger';
+import { getCacheCounters, getCacheStats } from 'graphile-cache';
+
+import { getBuildQueueDepth, getGraphileCounters } from '../middleware/graphile';
+import { getIntrospectionFilterCounters } from '../middleware/introspection-filter';
+import { getRewritePoolCounters } from '../middleware/rewrite-pool';
+import { getConnectionErrorGuardCounters } from './connection-error-guard';
+
+const log = new Logger('metrics-sampler');
+
+const DEFAULT_INTERVAL_MS = 10_000;
+const DEFAULT_METRICS_FILE = './metrics.jsonl';
+
+// =============================================================================
+// GC tracking (perf_hooks)
+//
+// A single process-global PerformanceObserver accumulates GC pause time and counts
+// by kind. Registered lazily the first time the sampler starts (so there is zero
+// overhead when GRAPHILE_DEBUG_METRICS is off) and torn down when the sampler stops.
+// =============================================================================
+
+interface GcKindStat {
+  count: number;
+  totalPauseMs: number;
+}
+
+type GcStats = Record<string, GcKindStat>;
+
+const gcStats: GcStats = {};
+let gcObserver: PerformanceObserver | null = null;
+
+// Map perf_hooks GC kind flags to stable, human-readable names for the metrics line.
+const GC_KIND_NAMES: Record<number, string> = {
+  [perfConstants.NODE_PERFORMANCE_GC_MINOR]: 'minor',
+  [perfConstants.NODE_PERFORMANCE_GC_MAJOR]: 'major',
+  [perfConstants.NODE_PERFORMANCE_GC_INCREMENTAL]: 'incremental',
+  [perfConstants.NODE_PERFORMANCE_GC_WEAKCB]: 'weakcb'
+};
+
+const startGcObserver = (): void => {
+  if (gcObserver) {
+    return;
+  }
+  try {
+    const observer = new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        // `detail.kind` is the modern accessor; fall back to the deprecated top-level
+        // `kind` for older Node. Guard: unknown kinds are bucketed by their numeric flag.
+        const kind =
+          (entry as { detail?: { kind?: number } }).detail?.kind ??
+          (entry as unknown as { kind?: number }).kind;
+        const name =
+          kind != null && GC_KIND_NAMES[kind] ? GC_KIND_NAMES[kind] : `kind_${kind ?? 'unknown'}`;
+        const stat = gcStats[name] ?? (gcStats[name] = { count: 0, totalPauseMs: 0 });
+        stat.count += 1;
+        stat.totalPauseMs += entry.duration;
+      }
+    });
+    observer.observe({ entryTypes: ['gc'] });
+    gcObserver = observer;
+  } catch (err) {
+    // GC observation is best-effort; a platform without 'gc' entries just omits GC data.
+    gcObserver = null;
+    log.warn('GC PerformanceObserver unavailable; metrics will omit GC data', err);
+  }
+};
+
+const stopGcObserver = (): void => {
+  if (gcObserver) {
+    try {
+      gcObserver.disconnect();
+    } catch {
+      // ignore — teardown is best-effort
+    }
+    gcObserver = null;
+  }
+};
+
+const snapshotGcStats = (): GcStats => {
+  const out: GcStats = {};
+  for (const [name, stat] of Object.entries(gcStats)) {
+    out[name] = { count: stat.count, totalPauseMs: stat.totalPauseMs };
+  }
+  return out;
+};
+
+// =============================================================================
+// Env parsing
+// =============================================================================
+
+const isEnabled = (): boolean => {
+  const raw = process.env.GRAPHILE_DEBUG_METRICS;
+  if (!raw) {
+    return false;
+  }
+  const normalized = raw.trim().toLowerCase();
+  return normalized === '1' || normalized === 'true';
+};
+
+const getIntervalMs = (): number => {
+  const raw = process.env.GRAPHILE_DEBUG_METRICS_INTERVAL_MS;
+  const parsed = raw ? Number.parseInt(raw, 10) : DEFAULT_INTERVAL_MS;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_INTERVAL_MS;
+};
+
+const getMetricsFile = (): string =>
+  process.env.GRAPHILE_DEBUG_METRICS_FILE || DEFAULT_METRICS_FILE;
+
+// =============================================================================
+// Sample
+// =============================================================================
+
+export interface MetricsSample {
+  ts: string;
+  rss: number;
+  heapUsed: number;
+  heapTotal: number;
+  external: number;
+  heap_size_limit: number;
+  cache: {
+    size: number;
+    keys: number;
+  };
+  counters: ReturnType<typeof getCacheCounters> &
+    ReturnType<typeof getGraphileCounters> & {
+      buildQueueDepth: number;
+      connGuard: ReturnType<typeof getConnectionErrorGuardCounters>;
+      rewritePool: ReturnType<typeof getRewritePoolCounters>;
+      introspectionFilter: ReturnType<typeof getIntrospectionFilterCounters>;
+    };
+  gc: GcStats;
+}
+
+/**
+ * Collect a single metrics sample. Cheap: a memoryUsage() call, a v8 heap-stats read,
+ * cache size/key-count, and integer counter snapshots. Exposed for tests and future
+ * promotion to a /metrics endpoint.
+ */
+export const collectMetricsSample = (): MetricsSample => {
+  const mem = process.memoryUsage();
+  const cacheStats = getCacheStats();
+  return {
+    ts: new Date().toISOString(),
+    rss: mem.rss,
+    heapUsed: mem.heapUsed,
+    heapTotal: mem.heapTotal,
+    external: mem.external,
+    heap_size_limit: v8.getHeapStatistics().heap_size_limit,
+    cache: {
+      size: cacheStats.size,
+      keys: cacheStats.keys.length
+    },
+    counters: {
+      ...getCacheCounters(),
+      ...getGraphileCounters(),
+      buildQueueDepth: getBuildQueueDepth(),
+      connGuard: getConnectionErrorGuardCounters(),
+      rewritePool: getRewritePoolCounters(),
+      introspectionFilter: getIntrospectionFilterCounters()
+    },
+    gc: snapshotGcStats()
+  };
+};
+
+// =============================================================================
+// Sampler
+// =============================================================================
+
+export interface MetricsSamplerHandle {
+  stop(): void;
+}
+
+/**
+ * Start the in-process metrics sampler.
+ *
+ * When GRAPHILE_DEBUG_METRICS is '1' or 'true', appends one JSON line per
+ * GRAPHILE_DEBUG_METRICS_INTERVAL_MS (default 10000ms) to GRAPHILE_DEBUG_METRICS_FILE
+ * (default ./metrics.jsonl). The interval timer is unref'd so it never keeps the
+ * process alive, and file writes swallow errors so metrics can never affect the server.
+ *
+ * Returns null (a true no-op, zero overhead) when disabled.
+ */
+export const startMetricsSampler = (): MetricsSamplerHandle | null => {
+  if (!isEnabled()) {
+    return null;
+  }
+
+  startGcObserver();
+
+  const intervalMs = getIntervalMs();
+  const file = getMetricsFile();
+
+  const writeSample = (): void => {
+    const line = `${JSON.stringify(collectMetricsSample())}\n`;
+    // Fire-and-forget; a failed metrics write must never impact request handling.
+    fs.appendFile(file, line, () => {
+      // swallow errors
+    });
+  };
+
+  // Emit an immediate baseline sample so the file has a line without waiting a full
+  // interval, then sample periodically.
+  writeSample();
+
+  const timer = setInterval(writeSample, intervalMs);
+  timer.unref();
+
+  log.info(`Metrics sampler writing every ${intervalMs}ms to ${file}`);
+
+  return {
+    stop(): void {
+      clearInterval(timer);
+      stopGcObserver();
+    }
+  };
+};
diff --git a/graphql/server/src/middleware/__tests__/blueprint.test.ts b/graphql/server/src/middleware/__tests__/blueprint.test.ts
new file mode 100644
index 0000000000..03b46e496a
--- /dev/null
+++ b/graphql/server/src/middleware/__tests__/blueprint.test.ts
@@ -0,0 +1,131 @@
+import {
+  computeBlueprintKey,
+  stripSchemaHashPrefix
+} from '../blueprint';
+
+describe('stripSchemaHashPrefix', () => {
+  it('strips a hashed tenant prefix down to the logical schema', () => {
+    expect(stripSchemaHashPrefix('marketplace-db-tenant1-5e6b13b2-app-public')).toBe(
+      'app-public'
+    );
+  });
+
+  it('returns control-plane / non-hashed schema names unchanged', () => {
+    expect(stripSchemaHashPrefix('services_public')).toBe('services_public');
+    expect(stripSchemaHashPrefix('metaschema_public')).toBe('metaschema_public');
+    expect(stripSchemaHashPrefix('app-public')).toBe('app-public');
+  });
+
+  it('handles multi-dash database names in the prefix', () => {
+    expect(stripSchemaHashPrefix('my-cool-db-name-deadbeef-auth-private')).toBe(
+      'auth-private'
+    );
+    expect(stripSchemaHashPrefix('app-5e6b13b2-public')).toBe('public');
+  });
+
+  it('only strips through the FIRST 8-hex segment, keeping later ones intact', () => {
+    expect(
+      stripSchemaHashPrefix('marketplace-db-tenant1-5e6b13b2-app-deadbeef-zone')
+    ).toBe('app-deadbeef-zone');
+  });
+
+  it('does not treat non-hex or wrong-length segments as a hash', () => {
+    // 'tenant11' is 8 chars but not all hex; 'abcdef1' is 7 hex chars.
+    expect(stripSchemaHashPrefix('marketplace-tenant11-app-public')).toBe(
+      'marketplace-tenant11-app-public'
+    );
+    expect(stripSchemaHashPrefix('marketplace-abcdef1-app-public')).toBe(
+      'marketplace-abcdef1-app-public'
+    );
+  });
+});
+
+describe('computeBlueprintKey', () => {
+  const base = {
+    logicalSchemas: ['app-public', 'auth-public'],
+    shapeFingerprint: 'fingerprint-a',
+    flags: { a: 1, b: 2 } as Record<string, any>,
+    apiName: 'customer-api',
+    mode: 'domain-lookup'
+  };
+
+  it('produces a stable "bp:"-prefixed sha256 hex key', () => {
+    const key = computeBlueprintKey(base);
+    expect(key).toMatch(/^bp:[0-9a-f]{64}$/);
+    expect(computeBlueprintKey(base)).toBe(key);
+  });
+
+  it('is stable across the key order of flags', () => {
+    const key1 = computeBlueprintKey({ ...base, flags: { a: 1, b: 2 } });
+    const key2 = computeBlueprintKey({ ...base, flags: { b: 2, a: 1 } });
+    expect(key1).toBe(key2);
+  });
+
+  it('is stable across the order of logical schemas', () => {
+    const key1 = computeBlueprintKey({
+      ...base,
+      logicalSchemas: ['app-public', 'auth-public']
+    });
+    const key2 = computeBlueprintKey({
+      ...base,
+      logicalSchemas: ['auth-public', 'app-public']
+    });
+    expect(key1).toBe(key2);
+  });
+
+  it('differs when the shape fingerprint differs', () => {
+    const key1 = computeBlueprintKey({ ...base, shapeFingerprint: 'fingerprint-a' });
+    const key2 = computeBlueprintKey({ ...base, shapeFingerprint: 'fingerprint-b' });
+    expect(key1).not.toBe(key2);
+  });
+
+  it('differs when flag values differ', () => {
+    const key1 = computeBlueprintKey({ ...base, flags: { a: 1, b: 2 } });
+    const key2 = computeBlueprintKey({ ...base, flags: { a: 1, b: 3 } });
+    expect(key1).not.toBe(key2);
+  });
+
+  it('treats undefined flags like an empty flag set', () => {
+    const key1 = computeBlueprintKey({ ...base, flags: undefined });
+    const key2 = computeBlueprintKey({ ...base, flags: {} });
+    expect(key1).toBe(key2);
+  });
+
+  it('differs when the mode or api name differs', () => {
+    expect(computeBlueprintKey({ ...base, mode: 'domain-lookup' })).not.toBe(
+      computeBlueprintKey({ ...base, mode: 'api-name-header' })
+    );
+    expect(computeBlueprintKey({ ...base, apiName: 'customer-api' })).not.toBe(
+      computeBlueprintKey({ ...base, apiName: 'other-api' })
+    );
+  });
+
+  it('treats null and empty api name identically', () => {
+    expect(computeBlueprintKey({ ...base, apiName: null })).toBe(
+      computeBlueprintKey({ ...base, apiName: '' })
+    );
+  });
+});
+
+describe('computeBlueprintKey dbname isolation (W3 fix)', () => {
+  const { computeBlueprintKey } = require('../blueprint');
+  const base = {
+    logicalSchemas: ['app-public'],
+    shapeFingerprint: 'f'.repeat(64),
+    flags: undefined as Record<string, any> | undefined,
+    apiName: 'api',
+    mode: 'public'
+  };
+
+  it('same-shape tenants in DIFFERENT physical databases get DIFFERENT keys', () => {
+    const a = computeBlueprintKey({ ...base, dbname: 'db_a' });
+    const b = computeBlueprintKey({ ...base, dbname: 'db_b' });
+    expect(a).not.toBe(b);
+  });
+
+  it('same dbname yields a stable key', () => {
+    expect(computeBlueprintKey({ ...base, dbname: 'db_a' })).toBe(
+      computeBlueprintKey({ ...base, dbname: 'db_a' })
+    );
+  });
+});
diff --git a/graphql/server/src/middleware/__tests__/build-timeout.test.ts b/graphql/server/src/middleware/__tests__/build-timeout.test.ts
new file mode 100644
index 0000000000..742c2df013
--- /dev/null
+++ b/graphql/server/src/middleware/__tests__/build-timeout.test.ts
@@ -0,0 +1,57 @@
+import { BuildRefusedError, raceBuildAgainstTimeout } from '../graphile';
+
+describe('BuildRefusedError', () => {
+  it('carries the 503 mapping contract (code + name) and the pressure ratio', () => {
+    const err = new BuildRefusedError(0.934);
+    expect(err.code).toBe('SERVICE_OVERLOADED');
+    expect(err.name).toBe('BuildRefusedError');
+    expect(err.message).toContain('0.93');
+    expect(err).toBeInstanceOf(Error);
+  });
+});
+
+describe('raceBuildAgainstTimeout', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('returns the built value and disarms the timer when the build wins', async () => {
+    const instance = { handler: 'built' };
+    const result = await raceBuildAgainstTimeout(Promise.resolve(instance), 180_000);
+    expect(result).toBe(instance);
+    // The load-bearing assertion: an armed timer here retains the built instance
+    // through the race reaction chain for the full timeout (the evict-churn OOM).
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('returns null when the wait expires, leaving no armed timer', async () => {
+    const never = new Promise<never>(() => {});
+    const race = raceBuildAgainstTimeout(never, 180_000);
+    jest.advanceTimersByTime(180_000);
+    await expect(race).resolves.toBeNull();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('disarms the timer when the build rejects', async () => {
+    const boom = new Error('build failed');
+    await expect(raceBuildAgainstTimeout(Promise.reject(boom), 180_000)).rejects.toBe(boom);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('propagates a late build failure to no one after a timeout (no unhandled timer state)', async () => {
+    let rejectBuild: (err: Error) => void;
+    const build = new Promise<never>((_resolve, reject) => {
+      rejectBuild = reject;
+    });
+    build.catch(() => { /* the dispatcher attaches its own handler; mirror that */ });
+    const race = raceBuildAgainstTimeout(build, 1_000);
+    jest.advanceTimersByTime(1_000);
+    await expect(race).resolves.toBeNull();
+    expect(jest.getTimerCount()).toBe(0);
+    rejectBuild!(new Error('late failure'));
+  });
+});
diff --git a/graphql/server/src/middleware/__tests__/graphile-pooling.test.ts b/graphql/server/src/middleware/__tests__/graphile-pooling.test.ts
new file mode 100644
index 0000000000..669586f65f
--- /dev/null
+++ b/graphql/server/src/middleware/__tests__/graphile-pooling.test.ts
@@ -0,0 +1,224 @@
+import type { Pool } from 'pg';
+
+import type { ApiStructure } from '../../types';
+import { isBlueprintPoolingEnabled } from '../blueprint';
+import { clearPoolDecisions, computePoolDecision, resolvePoolDecision } from '../pooling-decision';
+
+type QueryResult = { rows: Array<Record<string, unknown>> };
+
+const makeApi = (overrides: Partial<ApiStructure> = {}): ApiStructure =>
+  ({
+    dbname: 'constructive',
+    anonRole: 'anon',
+    roleName: 'authenticated',
+    schema: ['marketplace-db-tenant1-5e6b13b2-app-public'],
+    apiModules: [],
+    ...overrides
+  } as ApiStructure);
+
+// A mock Pool whose query() resolves queued results in call order. computePoolDecision
+// issues a single shape-fingerprint query.
+const makePool = (results: QueryResult[]): { pool: Pool; query: jest.Mock } => {
+  const query = jest.fn();
+  results.forEach((r) => query.mockResolvedValueOnce(r));
+  return { pool: { query } as unknown as Pool, query };
+};
+
+describe('computePoolDecision', () => {
+  afterEach(() => {
+    clearPoolDecisions();
+    jest.clearAllMocks();
+  });
+
+  it('falls back (pooling=false, key=svc_key) when realtime is enabled, without touching the DB', async () => {
+    const { pool, query } = makePool([]);
+    const api = makeApi({ databaseSettings: { enableRealtime: true } as ApiStructure['databaseSettings'] });
+
+    const decision = await computePoolDecision('svc-1', api, pool);
+
+    expect(decision).toEqual({ key: 'svc-1', pooling: false });
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it('falls back when the API exposes no schemas, without touching the DB', async () => {
+    const { pool, query } = makePool([]);
+    const api = makeApi({ schema: [] });
+
+    const decision = await computePoolDecision('svc-2', api, pool);
+
+    expect(decision).toEqual({ key: 'svc-2', pooling: false });
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it('pools a clean single-tenant shape and returns a stable bp: key', async () => {
+    const rows = [
+      { nspname: 'marketplace-db-tenant1-5e6b13b2-app-public', relname: 'products' },
+      { nspname: 'marketplace-db-tenant1-5e6b13b2-app-public', relname: 'orders' }
+    ];
+    const { pool, query } = makePool([{ rows }, { rows: [] }]);
+    const api = makeApi();
+
+    const decision = await computePoolDecision('svc-3', api, pool);
+
+    expect(decision.pooling).toBe(true);
+    expect(decision.key).toMatch(/^bp:[0-9a-f]{64}$/);
+    expect(query).toHaveBeenCalledTimes(1); // single catalog scan feeds the fingerprint
+  });
+
+  it('produces the SAME bp: key for two different physical tenants of the same shape', async () => {
+    const shapeRows = (hash: string) => [
+      { nspname: `marketplace-db-tenant-${hash}-app-public`, relname: 'orders' },
+      { nspname: `marketplace-db-tenant-${hash}-app-public`, relname: 'products' }
+    ];
+
+    const t1 = makePool([{ rows: shapeRows('5e6b13b2') }, { rows: [] }]);
+    const d1 = await computePoolDecision(
+      'svc-t1',
+      makeApi({ schema: ['marketplace-db-tenant-5e6b13b2-app-public'] }),
+      t1.pool
+    );
+
+    const t2 = makePool([{ rows: shapeRows('deadbeef') }, { rows: [] }]);
+    const d2 = await computePoolDecision(
+      'svc-t2',
+      makeApi({ schema: ['marketplace-db-tenant-deadbeef-app-public'] }),
+      t2.pool
+    );
+
+    expect(d1.pooling).toBe(true);
+    expect(d2.pooling).toBe(true);
+    expect(d1.key).toBe(d2.key); // same logical shape → shared blueprint instance
+  });
+
+  it('threads api.logicalSchemas into the key, deriving it from physical schema only when absent', async () => {
+    // Identical fingerprint rows across all three calls: only logicalSchemas varies,
+    // so any key difference is attributable solely to the logicalSchemas input.
+    const fpRows = [{ nspname: 'shop-5e6b13b2-app-public', relname: 'orders' }];
+
+    // Explicit logicalSchemas that DIFFER from the stripped physical name.
+    const a = makePool([{ rows: fpRows }, { rows: [] }]);
+    const dExplicitDiff = await computePoolDecision(
+      'svc-a',
+      makeApi({ schema: ['shop-5e6b13b2-app-public'], logicalSchemas: ['custom-logical'] }),
+      a.pool
+    );
+
+    // No logicalSchemas → derived from schema.map(stripSchemaHashPrefix) = ['app-public'].
+    const b = makePool([{ rows: fpRows }, { rows: [] }]);
+    const dDerived = await computePoolDecision(
+      'svc-b',
+      makeApi({ schema: ['shop-5e6b13b2-app-public'], logicalSchemas: undefined }),
+      b.pool
+    );
+
+    // Explicit logicalSchemas EQUAL to the derived value.
+    const c = makePool([{ rows: fpRows }, { rows: [] }]);
+    const dExplicitSame = await computePoolDecision(
+      'svc-c',
+      makeApi({ schema: ['shop-5e6b13b2-app-public'], logicalSchemas: ['app-public'] }),
+      c.pool
+    );
+
+    expect(dExplicitDiff.key).not.toBe(dDerived.key); // provided logicalSchemas is honored
+    expect(dExplicitSame.key).toBe(dDerived.key); // ?? fallback derivation matches
+  });
+
+  it('relation-name collisions across schemas are poolable under qualified SQL', async () => {
+    const rows = [
+      { nspname: 'shop-5e6b13b2-auth-public', relname: 'identity_providers' },
+      { nspname: 'shop-5e6b13b2-auth-private', relname: 'identity_providers' }
+    ];
+    const { pool } = makePool([{ rows }]);
+    const api = makeApi({ schema: ['shop-5e6b13b2-auth-public', 'shop-5e6b13b2-auth-private'] });
+
+    const decision = await computePoolDecision('svc-4', api, pool);
+
+    expect(decision.pooling).toBe(true);
+    expect(decision.key).toMatch(/^bp:[0-9a-f]{64}$/);
+  });
+
+  it('falls back (never throws) when a catalog probe rejects', async () => {
+    const query = jest.fn().mockRejectedValue(new Error('connection reset'));
+    const api = makeApi();
+
+    const decision = await computePoolDecision('svc-5', api, { query } as unknown as Pool);
+
+    expect(decision).toEqual({ key: 'svc-5', pooling: false, transient: true });
+  });
+});
+
+describe('resolvePoolDecision caching', () => {
+  afterEach(() => {
+    clearPoolDecisions();
+    jest.clearAllMocks();
+  });
+
+  it('memoizes the decision per svc_key (one probe pair) until cleared', async () => {
+    const { pool, query } = makePool([
+      { rows: [{ nspname: 'shop-5e6b13b2-app-public', relname: 'orders' }] },
+      { rows: [] }
+    ]);
+    const api = makeApi({ schema: ['shop-5e6b13b2-app-public'] });
+
+    const first = await resolvePoolDecision('svc-cache', api, pool);
+    const second = await resolvePoolDecision('svc-cache', api, pool);
+
+    expect(first).toBe(second); // same cached object identity
+    expect(first.pooling).toBe(true);
+    expect(query).toHaveBeenCalledTimes(1); // NOT 2 — second call served from cache
+
+    // clearPoolDecisions() forces the next request to re-probe.
+    clearPoolDecisions();
+    query.mockResolvedValueOnce({ rows: [{ nspname: 'shop-5e6b13b2-app-public', relname: 'orders' }] });
+    await resolvePoolDecision('svc-cache', api, pool);
+    expect(query).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('blueprint pooling flag gate (flag-off ⇒ key stays svc_key in the dispatcher)', () => {
+  const original = process.env.GRAPHILE_BLUEPRINT_POOLING;
+
+  afterEach(() => {
+    if (original === undefined) delete process.env.GRAPHILE_BLUEPRINT_POOLING;
+    else process.env.GRAPHILE_BLUEPRINT_POOLING = original;
+  });
+
+  it('is disabled by default — the dispatcher never runs a decision and uses req.svc_key', () => {
+    delete process.env.GRAPHILE_BLUEPRINT_POOLING;
+    expect(isBlueprintPoolingEnabled()).toBe(false);
+  });
+
+  it("enables only on '1' or 'true'", () => {
+    process.env.GRAPHILE_BLUEPRINT_POOLING = '1';
+    expect(isBlueprintPoolingEnabled()).toBe(true);
+    process.env.GRAPHILE_BLUEPRINT_POOLING = 'true';
+    expect(isBlueprintPoolingEnabled()).toBe(true);
+    process.env.GRAPHILE_BLUEPRINT_POOLING = 'yes';
+    expect(isBlueprintPoolingEnabled()).toBe(false);
+  });
+});
+
+describe('transient probe failures are not memoized (W3 fix)', () => {
+  afterEach(() => {
+    clearPoolDecisions();
+    jest.clearAllMocks();
+  });
+
+  it('re-probes on the next request after a thrown catalog probe', async () => {
+    const query = jest.fn();
+    query.mockRejectedValueOnce(new Error('connection reset'));
+    query.mockResolvedValueOnce({
+      rows: [{ nspname: 'shop-5e6b13b2-app-public', relname: 'orders' }]
+    });
+    const pool = { query } as unknown as Pool;
+    const api = makeApi({ schema: ['shop-5e6b13b2-app-public'] });
+
+    const first = await resolvePoolDecision('svc-transient', api, pool);
+    expect(first.pooling).toBe(false);
+    expect(first.transient).toBe(true);
+
+    const second = await resolvePoolDecision('svc-transient', api, pool);
+    expect(second.pooling).toBe(true); // re-probed and now poolable
+    expect(query).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/graphql/server/src/middleware/__tests__/graphile-recoalesce.test.ts b/graphql/server/src/middleware/__tests__/graphile-recoalesce.test.ts
new file mode 100644
index 0000000000..7ea244f2f1
--- /dev/null
+++ b/graphql/server/src/middleware/__tests__/graphile-recoalesce.test.ts
@@ -0,0 +1,79 @@
+import type { NextFunction, Request, Response } from 'express';
+import type { GraphileCacheEntry } from 'graphile-cache';
+
+import { BuildRefusedError, clearInFlightMap, graphile, setInFlightForTest } from '../graphile';
+
+/**
+ * Regression test for the Phase C re-coalesce load-shed hole.
+ *
+ * Contract (commit 46636d4b4): BuildRefusedError maps to 503 SERVICE_OVERLOADED +
+ * Retry-After "for the requester and every coalesced waiter." A re-coalescing
+ * waiter awaits a fresh in-flight build at the Phase C re-coalesce await. Pre-fix
+ * that await was unguarded, so a BuildRefusedError surfacing there escaped to the
+ * outer catch and became a generic 500 INTERNAL_ERROR with no Retry-After —
+ * contradicting the contract on the exact memory-pressure path the error exists for.
+ *
+ * The re-coalesce await is reached before the request-time pressure gate, so the
+ * real (empty) cache naturally misses and no build machinery runs; seeding the
+ * in-flight map with a rejecting promise drives the path deterministically.
+ */
+describe('graphile dispatcher — Phase C re-coalesce refusal mapping', () => {
+  const key = 'svc-recoalesce-test';
+
+  const makeRes = () => {
+    const headers: Record<string, string> = {};
+    const res: any = { headersSent: false };
+    res.setHeader = jest.fn((name: string, value: string) => {
+      headers[name] = value;
+    });
+    res.status = jest.fn((code: number) => {
+      res.statusCode = code;
+      return res;
+    });
+    res.json = jest.fn((payload: unknown) => {
+      res.body = payload;
+      return res;
+    });
+    return { res: res as Response, headers };
+  };
+
+  const makeReq = (): Request =>
+    ({
+      requestId: 'test-req',
+      svc_key: key,
+      api: {
+        dbname: 'constructive',
+        anonRole: 'anon',
+        roleName: 'authenticated',
+        schema: ['app-public']
+      }
+    } as unknown as Request);
+
+  afterEach(() => {
+    clearInFlightMap();
+  });
+
+  it('maps a BuildRefusedError on the re-coalesce await to 503 SERVICE_OVERLOADED + Retry-After', async () => {
+    // A rejecting in-flight promise that is NOT self-deleting, so it survives from
+    // Phase B (which falls through on the rejection) into the Phase C re-coalesce
+    // read — mirroring a fresh owner's build that refuses under late heap pressure.
+    const refused: Promise<GraphileCacheEntry> = Promise.reject(new BuildRefusedError(0.98));
+    refused.catch(() => { /* guard: both awaits inside the dispatcher handle it */ });
+    setInFlightForTest(key, refused);
+
+    const handler = graphile({} as never);
+    const { res, headers } = makeRes();
+    const next = jest.fn() as unknown as NextFunction;
+
+    await handler(makeReq(), res, next);
+
+    expect((res.status as jest.Mock)).toHaveBeenCalledWith(503);
+    expect(headers['Retry-After']).toBe('15');
+    expect((res.json as jest.Mock).mock.calls[0][0]).toEqual({
+      error: { code: 'SERVICE_OVERLOADED', message: 'Server is at critical memory pressure; retry shortly' }
+    });
+    // The pre-fix defect: a generic 500 with no Retry-After from the outer catch.
+    expect((res.status as jest.Mock)).not.toHaveBeenCalledWith(500);
+    expect(next).not.toHaveBeenCalled();
+  });
+});
diff --git a/graphql/server/src/middleware/__tests__/introspection-filter.test.ts b/graphql/server/src/middleware/__tests__/introspection-filter.test.ts
new file mode 100644
index 0000000000..0c13f4a96d
--- /dev/null
+++ b/graphql/server/src/middleware/__tests__/introspection-filter.test.ts
@@ -0,0 +1,349 @@
+import { makeIntrospectionQuery } from 'pg-introspection';
+
+import {
+  buildFilteredIntrospectionQuery,
+  createIntrospectionFilterCounters,
+  createIntrospectionFilterPool,
+  createIntrospectionInterceptor,
+  getIntrospectionFilterCounters,
+  isIntrospectionFilterEnabled,
+  isIntrospectionQuery
+} from '../introspection-filter';
+import {
+  createRewriteCounters,
+  createRewritingPool,
+  POOL_SCHEMAS_GUC
+} from '../rewrite-pool';
+
+// The exact runtime gate substring (single backslash before the underscore).
+// Derived here so tests fail loudly if the installed package ever drifts.
+const GATE_SUBSTRING =
+  "in (select namespaces._id from namespaces where nspname <> 'information_schema' and nspname not like 'pg\\_%')";
+
+const STOCK = makeIntrospectionQuery();
+
+const countOccurrences = (haystack: string, needle: string): number =>
+  haystack.split(needle).length - 1;
+
+const originalEnv = { ...process.env };
+afterEach(() => {
+  process.env = { ...originalEnv };
+});
+
+// =============================================================================
+// Env flag
+// =============================================================================
+
+describe('isIntrospectionFilterEnabled', () => {
+  it("is true only for '1' or 'true'", () => {
+    process.env.GRAPHILE_INTROSPECTION_FILTER = '1';
+    expect(isIntrospectionFilterEnabled()).toBe(true);
+    process.env.GRAPHILE_INTROSPECTION_FILTER = 'true';
+    expect(isIntrospectionFilterEnabled()).toBe(true);
+    process.env.GRAPHILE_INTROSPECTION_FILTER = '0';
+    expect(isIntrospectionFilterEnabled()).toBe(false);
+    delete process.env.GRAPHILE_INTROSPECTION_FILTER;
+    expect(isIntrospectionFilterEnabled()).toBe(false);
+  });
+});
+
+// =============================================================================
+// 1. THE PINNING TEST
+// =============================================================================
+
+describe('buildFilteredIntrospectionQuery — pinned against installed pg-introspection', () => {
+  it('recognizes the stock query', () => {
+    expect(isIntrospectionQuery(STOCK)).toBe(true);
+    // The stock text carries the gate exactly four times.
+    expect(countOccurrences(STOCK, GATE_SUBSTRING)).toBe(4);
+  });
+
+  it('rewrites all four gates and preserves the pg_catalog type branch', () => {
+    const filtered = buildFilteredIntrospectionQuery(STOCK, ['t1-aaaa-app_public', 'public']);
+    expect(filtered).not.toBeNull();
+    // The injected `= any (array[...])` gate appears exactly four times...
+    expect(countOccurrences(filtered as string, 'nspname = any (array[')).toBe(4);
+    // ...and zero stock gates remain.
+    expect(countOccurrences(filtered as string, GATE_SUBSTRING)).toBe(0);
+    // pg_catalog types survive via the intact OR branch.
+    expect((filtered as string).includes("'pg_catalog'::regnamespace")).toBe(true);
+    // Sorted, escaped literals present.
+    expect((filtered as string).includes("array['public', 't1-aaaa-app_public']::text[]")).toBe(true);
+  });
+});
+
+// =============================================================================
+// 2. Gate mismatch
+// =============================================================================
+
+describe('buildFilteredIntrospectionQuery — gate mismatch', () => {
+  it('returns null when the gate does not appear exactly four times', () => {
+    // Remove one of the four gate occurrences -> three remain.
+    const doctored = STOCK.replace(GATE_SUBSTRING, 'in (select namespaces._id from namespaces where true)');
+    expect(countOccurrences(doctored, GATE_SUBSTRING)).toBe(3);
+    expect(buildFilteredIntrospectionQuery(doctored, ['public'])).toBeNull();
+  });
+});
+
+// =============================================================================
+// 3. Literal escaping / defensive drops
+// =============================================================================
+
+describe('buildFilteredIntrospectionQuery — literal escaping', () => {
+  it("doubles single quotes and drops pg_ / information_schema names", () => {
+    const filtered = buildFilteredIntrospectionQuery(STOCK, [
+      "o'brien",
+      'pg_temp_1',
+      'information_schema',
+      'public'
+    ]);
+    expect(filtered).not.toBeNull();
+    const text = filtered as string;
+    expect(text.includes("'o''brien'")).toBe(true);
+    expect(text.includes("'public'")).toBe(true);
+    expect(text.includes("'pg_temp_1'")).toBe(false);
+    // 'information_schema' appears in the stock text elsewhere, but never as an
+    // injected array literal.
+    expect(text.includes("array['information_schema'")).toBe(false);
+    expect(text.includes(", 'information_schema'")).toBe(false);
+  });
+});
+
+// =============================================================================
+// 4. isIntrospectionQuery negatives
+// =============================================================================
+
+describe('isIntrospectionQuery — negatives', () => {
+  it('rejects the adaptor settings query, DEALLOCATE, and a plain SELECT', () => {
+    const settings =
+      'select set_config(el->>0, el->>1, true) from json_array_elements($1::json) el';
+    expect(isIntrospectionQuery(settings)).toBe(false);
+    expect(isIntrospectionQuery('deallocate all')).toBe(false);
+    expect(isIntrospectionQuery('select introspection_version from t')).toBe(false);
+  });
+
+  it('rejects a long query that merely mentions introspection_version', () => {
+    const long = 'select ' + 'a,'.repeat(3000) + " 'introspection_version' from t";
+    expect(long.length).toBeGreaterThan(5000);
+    expect(isIntrospectionQuery(long)).toBe(false);
+  });
+});
+
+// =============================================================================
+// 5. Closure loop + interceptor
+// =============================================================================
+
+const scriptedClient = (rounds: any[][]) => {
+  let i = 0;
+  return {
+    query: jest.fn((_sql: string, _values?: any[]) => {
+      const rows = rounds[i] ?? [];
+      i += 1;
+      return Promise.resolve({ rows });
+    })
+  };
+};
+
+describe('createIntrospectionInterceptor — closure loop', () => {
+  beforeEach(() => {
+    process.env.GRAPHILE_INTROSPECTION_FILTER = '1';
+  });
+
+  it('accumulates served ∪ public ∪ discovered, then filters', async () => {
+    const counters = createIntrospectionFilterCounters();
+    const interceptor = createIntrospectionInterceptor({ servedSchemas: ['t1'], counters });
+    // Round 1 discovers services_public; round 2 discovers nothing.
+    const client = scriptedClient([[{ nspname: 'services_public' }], []]);
+
+    const swapped = await (interceptor(STOCK, client) as Promise<string>);
+
+    // keep set = public, t1, services_public
+    expect(swapped.includes("'public'")).toBe(true);
+    expect(swapped.includes("'t1'")).toBe(true);
+    expect(swapped.includes("'services_public'")).toBe(true);
+    expect(countOccurrences(swapped, GATE_SUBSTRING)).toBe(0);
+
+    expect(counters.discoveries).toBe(1);
+    expect(counters.swaps).toBe(1);
+    expect(counters.closureTruncations).toBe(0);
+    expect(counters.keepNamespaceCount).toBe(3);
+    // Two closure rounds ran (the second returned nothing, ending the loop).
+    expect(client.query).toHaveBeenCalledTimes(2);
+  });
+
+  it('memoizes: a second call reuses the first discovery', async () => {
+    const counters = createIntrospectionFilterCounters();
+    const interceptor = createIntrospectionInterceptor({ servedSchemas: ['t1'], counters });
+    const client = scriptedClient([[], []]);
+
+    const a = await (interceptor(STOCK, client) as Promise<string>);
+    const b = await (interceptor(STOCK, client) as Promise<string>);
+    expect(a).toBe(b);
+    expect(counters.discoveries).toBe(1);
+    expect(client.query).toHaveBeenCalledTimes(1); // one round (empty) only
+  });
+
+  it('rejects when the discovery query throws', async () => {
+    const counters = createIntrospectionFilterCounters();
+    const interceptor = createIntrospectionInterceptor({ servedSchemas: ['t1'], counters });
+    const client = {
+      query: jest.fn(() => Promise.reject(new Error('boom')))
+    };
+    await expect(interceptor(STOCK, client) as Promise<string>).rejects.toThrow('boom');
+    expect(counters.discoveries).toBe(1);
+    expect(counters.swaps).toBe(0);
+  });
+
+  it('returns null when disabled, served-empty, or non-introspection', () => {
+    const client = scriptedClient([[]]);
+    // disabled
+    process.env.GRAPHILE_INTROSPECTION_FILTER = '0';
+    expect(createIntrospectionInterceptor({ servedSchemas: ['t1'] })(STOCK, client)).toBeNull();
+    // enabled again
+    process.env.GRAPHILE_INTROSPECTION_FILTER = '1';
+    // no served schemas
+    expect(createIntrospectionInterceptor({ servedSchemas: [] })(STOCK, client)).toBeNull();
+    // non-introspection text
+    expect(createIntrospectionInterceptor({ servedSchemas: ['t1'] })('select 1', client)).toBeNull();
+  });
+});
+
+// =============================================================================
+// 6. createIntrospectionFilterPool (dedicated)
+// =============================================================================
+
+const introspectingClient = (rounds: any[][]) => {
+  let round = 0;
+  const query = jest.fn((arg: any, _values?: any[]) => {
+    if (typeof arg === 'string' && arg.includes('kept as')) {
+      const rows = rounds[round] ?? [];
+      round += 1;
+      return Promise.resolve({ rows });
+    }
+    return Promise.resolve({ rows: [] });
+  });
+  return { query, release: jest.fn(), on: jest.fn() };
+};
+
+const sentConfigTexts = (client: { query: jest.Mock }): string[] =>
+  client.query.mock.calls.map((c: any[]) => (typeof c[0] === 'string' ? c[0] : c[0]?.text));
+
+describe('createIntrospectionFilterPool — dedicated wrapper', () => {
+  beforeEach(() => {
+    process.env.GRAPHILE_INTROSPECTION_FILTER = '1';
+  });
+
+  it('swaps the introspection query and leaves other queries untouched', async () => {
+    const counters = createIntrospectionFilterCounters();
+    const client = introspectingClient([[], []]);
+    const pool = { connect: jest.fn().mockResolvedValue(client) };
+    const wrapped = createIntrospectionFilterPool(pool, { servedSchemas: ['t1'], counters });
+
+    const c = await wrapped.connect();
+
+    // A normal query passes straight through.
+    await c.query('select 1 from t');
+    expect(client.query).toHaveBeenCalledWith('select 1 from t');
+
+    // Introspection is discovered + swapped.
+    await c.query({ text: STOCK });
+    const introspectionCall = client.query.mock.calls.find(
+      (call: any[]) => call[0] && typeof call[0] === 'object' && typeof call[0].text === 'string' &&
+        call[0].text.includes('as introspection')
+    );
+    expect(introspectionCall).toBeDefined();
+    const swapped = introspectionCall[0].text as string;
+    expect(countOccurrences(swapped, 'nspname = any (array[')).toBe(4);
+    expect(swapped.includes("'t1'")).toBe(true);
+    expect(counters.swaps).toBe(1);
+  });
+
+  it('wraps clients handed back via callback-style connect', (done) => {
+    const client = introspectingClient([[]]);
+    const pool = {
+      connect: (cb: any) => cb(null, client, jest.fn())
+    };
+    const wrapped = createIntrospectionFilterPool(pool, { servedSchemas: ['t1'] });
+
+    wrapped.connect((err: any, c: any) => {
+      expect(err).toBeNull();
+      c.query('select 1')
+        .then(() => {
+          expect(client.query).toHaveBeenCalledWith('select 1');
+          done();
+        })
+        .catch(done);
+    });
+  });
+});
+
+// =============================================================================
+// 7. rewrite-pool integration
+// =============================================================================
+
+const logicalName = (name: string): string => name.split('-').slice(2).join('-');
+const CANON_APP = 'app-11111111-app-public';
+const TENANT_APP = 'app-22222222-app-public';
+
+const settingsQuery = (schemas: string[]) => ({
+  text: 'select set_config(el->>0, el->>1, true) from json_array_elements($1::json) el',
+  values: [JSON.stringify([['role', 'app_user'], [POOL_SCHEMAS_GUC, JSON.stringify(schemas)]])]
+});
+
+describe('createRewritingPool — introspection filter integration', () => {
+  beforeEach(() => {
+    process.env.GRAPHILE_INTROSPECTION_FILTER = '1';
+  });
+
+  it('applies settings, swaps introspection (not identifier-rewritten), still rewrites tenant SQL', async () => {
+    const client = introspectingClient([[], []]);
+    const pool = { connect: jest.fn().mockResolvedValue(client), query: jest.fn(), on: jest.fn() };
+    const counters = createRewriteCounters();
+    const wrapped = createRewritingPool(pool, {
+      canonicalSchemas: [CANON_APP],
+      logicalName,
+      counters,
+      introspectionFilter: { servedSchemas: [CANON_APP] }
+    });
+
+    const c = await wrapped.connect();
+
+    // Settings establish the tenant map.
+    await c.query(settingsQuery([TENANT_APP, 'public']));
+    expect(counters.settingsParses).toBe(1);
+
+    // Introspection: swapped, NOT identifier-rewritten, no fail-closed.
+    await c.query({ text: STOCK });
+    const introspectionCall = client.query.mock.calls.find(
+      (call: any[]) => call[0] && typeof call[0] === 'object' &&
+        typeof call[0].text === 'string' && call[0].text.includes('as introspection')
+    );
+    expect(introspectionCall).toBeDefined();
+    const swapped = introspectionCall[0].text as string;
+    expect(countOccurrences(swapped, 'nspname = any (array[')).toBe(4);
+    expect(countOccurrences(swapped, GATE_SUBSTRING)).toBe(0);
+    // Introspection was not treated as a rewrite target.
+    expect(counters.failClosed).toBe(0);
+
+    // A normal tenant query is still identifier-rewritten as before.
+    await c.query({ text: `select from "${CANON_APP}"."t"` });
+    const rewritten = sentConfigTexts(client).find((t) => t && t.includes(TENANT_APP));
+    expect(rewritten).toBe(`select from "${TENANT_APP}"."t"`);
+    expect(counters.rewrittenQueries).toBeGreaterThanOrEqual(1);
+  });
+
+  it('feeds the process-wide introspection-filter counters', async () => {
+    const before = getIntrospectionFilterCounters().swaps;
+    const client = introspectingClient([[]]);
+    const pool = { connect: jest.fn().mockResolvedValue(client), query: jest.fn(), on: jest.fn() };
+    const wrapped = createRewritingPool(pool, {
+      canonicalSchemas: [CANON_APP],
+      logicalName,
+      introspectionFilter: { servedSchemas: [CANON_APP] }
+    });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery([TENANT_APP, 'public']));
+    await c.query({ text: STOCK });
+    expect(getIntrospectionFilterCounters().swaps).toBe(before + 1);
+  });
+});
diff --git a/graphql/server/src/middleware/__tests__/rewrite-pool.test.ts b/graphql/server/src/middleware/__tests__/rewrite-pool.test.ts
new file mode 100644
index 0000000000..0113e8ad8e
--- /dev/null
+++ b/graphql/server/src/middleware/__tests__/rewrite-pool.test.ts
@@ -0,0 +1,637 @@
+import {
+  containsQuotedIdentifier,
+  createRewriteCounters,
+  createRewritingPool,
+  getRewritePoolCounters,
+  POOL_SCHEMAS_GUC,
+  RewriteCounters,
+  rewriteQuotedIdentifiers
+} from '../rewrite-pool';
+
+// -----------------------------------------------------------------------------
+// Fixtures: physical schemas shaped `<db>-<hash8>-<rest>`; the logical name is
+// everything past the first two dash segments, so a1111111/a2222222 tenants of
+// the same shape collapse to the same logical name.
+// -----------------------------------------------------------------------------
+
+const logicalName = (name: string): string => name.split('-').slice(2).join('-');
+
+const CANON_APP = 'app-11111111-app-public';
+const CANON_AUTH = 'app-11111111-auth-public';
+const TENANT_APP = 'app-22222222-app-public';
+const TENANT_AUTH = 'app-22222222-auth-public';
+
+const canonicalSchemas = [CANON_APP, CANON_AUTH];
+const tenantSchemas = [TENANT_APP, TENANT_AUTH, 'public'];
+
+const settingsQuery = (schemas: string[]) => ({
+  text: 'select set_config(el->>0, el->>1, true) from json_array_elements($1::json) el',
+  values: [JSON.stringify([['role', 'app_user'], [POOL_SCHEMAS_GUC, JSON.stringify(schemas)]])]
+});
+
+const makeClient = () => ({
+  query: jest.fn().mockResolvedValue({ rows: [] }),
+  release: jest.fn(),
+  on: jest.fn(),
+  escapeIdentifier: jest.fn((s: string) => `"${s}"`)
+});
+
+const makePool = (client: ReturnType<typeof makeClient>) => ({
+  query: jest.fn().mockResolvedValue({ rows: [] }),
+  connect: jest.fn().mockResolvedValue(client),
+  on: jest.fn(),
+  end: jest.fn()
+});
+
+const setup = (overrides: Partial<Parameters<typeof createRewritingPool>[1]> = {}) => {
+  const counters = createRewriteCounters();
+  const client = makeClient();
+  const pool = makePool(client);
+  const wrapped = createRewritingPool(pool, {
+    canonicalSchemas,
+    logicalName,
+    counters,
+    ...overrides
+  });
+  return { counters, client, pool, wrapped };
+};
+
+// Text of the Nth (0-based) call to the raw client query mock.
+const sentText = (client: ReturnType<typeof makeClient>, n: number): string => {
+  const arg = client.query.mock.calls[n][0];
+  return typeof arg === 'string' ? arg : arg.text;
+};
+
+// =============================================================================
+// Pure lexer: rewriteQuotedIdentifiers
+// =============================================================================
+
+describe('rewriteQuotedIdentifiers', () => {
+  const map = new Map([[CANON_APP, TENANT_APP]]);
+
+  it('replaces every quoted occurrence, including ::cast enum refs', () => {
+    const input = `select "${CANON_APP}"."t".*, x::"${CANON_APP}"."my_enum" from "${CANON_APP}"."t"`;
+    const expected = `select "${TENANT_APP}"."t".*, x::"${TENANT_APP}"."my_enum" from "${TENANT_APP}"."t"`;
+    expect(rewriteQuotedIdentifiers(input, map)).toBe(expected);
+  });
+
+  it('returns the input unchanged (byte-identical) when nothing matches', () => {
+    const input = 'select "users"."id" from "users"';
+    expect(rewriteQuotedIdentifiers(input, map)).toBe(input);
+  });
+
+  describe('never touches non-identifier regions', () => {
+    const m = new Map([['canon', 'TENANT']]);
+
+    it('single-quoted literal incl. doubled-quote escape', () => {
+      const input = `select '"canon" it''s "canon"', "canon"`;
+      expect(rewriteQuotedIdentifiers(input, m)).toBe(`select '"canon" it''s "canon"', "TENANT"`);
+    });
+
+    it("E-string with backslash escapes and embedded quotes", () => {
+      // Actual text: E'a\'b "canon" c' || "canon"
+      const input = `E'a\\'b "canon" c' || "canon"`;
+      expect(rewriteQuotedIdentifiers(input, m)).toBe(`E'a\\'b "canon" c' || "TENANT"`);
+    });
+
+    it('$$ and $tag$ dollar-quoted bodies', () => {
+      const input = `$$ "canon" $$ || $tag$ x "canon" y $tag$ || "canon"`;
+      expect(rewriteQuotedIdentifiers(input, m)).toBe(`$$ "canon" $$ || $tag$ x "canon" y $tag$ || "TENANT"`);
+    });
+
+    it('line comments and nested block comments', () => {
+      const line = `-- "canon"\n"canon"`;
+      expect(rewriteQuotedIdentifiers(line, m)).toBe(`-- "canon"\n"TENANT"`);
+
+      const block = `/* "canon" /* "canon" */ still "canon" */ "canon"`;
+      expect(rewriteQuotedIdentifiers(block, m)).toBe(`/* "canon" /* "canon" */ still "canon" */ "TENANT"`);
+    });
+  });
+
+  it('does not replace an identifier that merely prefixes a longer one', () => {
+    const m = new Map([['canon', 'TENANT']]);
+    expect(rewriteQuotedIdentifiers('"canon_extra" "canon"', m)).toBe('"canon_extra" "TENANT"');
+  });
+
+  it('matches on the unescaped value of an identifier with embedded ""', () => {
+    const m = new Map([['ca"non', 'TENANT']]);
+    expect(rewriteQuotedIdentifiers('"ca""non"', m)).toBe('"TENANT"');
+  });
+
+  it('escapes a " inside the replacement value', () => {
+    const m = new Map([['canon', 'ten"ant']]);
+    expect(rewriteQuotedIdentifiers('"canon"', m)).toBe('"ten""ant"');
+  });
+});
+
+// =============================================================================
+// Pure lexer: containsQuotedIdentifier
+// =============================================================================
+
+describe('containsQuotedIdentifier', () => {
+  const names = new Set([CANON_APP]);
+
+  it('true only for a complete quoted token match', () => {
+    expect(containsQuotedIdentifier(`from "${CANON_APP}"."t"`, names)).toBe(true);
+    expect(containsQuotedIdentifier(`from "${CANON_APP}_extra"."t"`, names)).toBe(false);
+  });
+
+  it('ignores matches inside strings and comments', () => {
+    expect(containsQuotedIdentifier(`select '"${CANON_APP}"'`, names)).toBe(false);
+    expect(containsQuotedIdentifier(`-- "${CANON_APP}"`, names)).toBe(false);
+    expect(containsQuotedIdentifier(`$$ "${CANON_APP}" $$`, names)).toBe(false);
+  });
+});
+
+// =============================================================================
+// Wrapper: end-to-end
+// =============================================================================
+
+describe('createRewritingPool — settings + rewriting', () => {
+  it('passes the settings query through byte-identical, then rewrites later queries', async () => {
+    const { client, wrapped } = setup();
+    const c = await wrapped.connect();
+
+    const sq = settingsQuery(tenantSchemas);
+    await c.query(sq);
+    // Forwarded untouched (same object, identical text/values).
+    expect(client.query).toHaveBeenNthCalledWith(1, sq);
+
+    await c.query({ text: `select * from "${CANON_APP}"."users" join "${CANON_AUTH}"."roles" using (id)` });
+    expect(sentText(client, 1)).toBe(
+      `select * from "${TENANT_APP}"."users" join "${TENANT_AUTH}"."roles" using (id)`
+    );
+  });
+
+  it('supports string and (text, values) call forms', async () => {
+    const { client, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    await c.query(`select from "${CANON_APP}"."t"`);
+    expect(sentText(client, 1)).toBe(`select from "${TENANT_APP}"."t"`);
+
+    await c.query(`select from "${CANON_APP}"."t" where x = $1`, [1]);
+    expect(sentText(client, 2)).toBe(`select from "${TENANT_APP}"."t" where x = $1`);
+    expect(client.query.mock.calls[2][1]).toEqual([1]);
+  });
+
+  it('does not mutate the caller-supplied query config', async () => {
+    const { client, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    const config = { text: `select from "${CANON_APP}"."t"`, name: 'p1' };
+    await c.query(config);
+    expect(config.text).toBe(`select from "${CANON_APP}"."t"`);
+    expect(config.name).toBe('p1');
+    // The forwarded object is a clone with rewritten fields.
+    expect(client.query.mock.calls[1][0]).not.toBe(config);
+    expect(sentText(client, 1)).toBe(`select from "${TENANT_APP}"."t"`);
+  });
+
+  it('wraps clients handed back via callback-style connect', (done) => {
+    const client = makeClient();
+    const pool = {
+      connect: (cb: any) => cb(null, client, jest.fn()),
+      query: jest.fn()
+    };
+    const wrapped = createRewritingPool(pool, { canonicalSchemas, logicalName });
+
+    wrapped.connect((err: any, c: any) => {
+      expect(err).toBeNull();
+      c.query(settingsQuery(tenantSchemas));
+      c.query({ text: `select from "${CANON_APP}"."t"` });
+      expect(sentText(client, 1)).toBe(`select from "${TENANT_APP}"."t"`);
+      done();
+    });
+  });
+
+  it('forwards non-query members bound to the raw client', async () => {
+    const { client, wrapped } = setup();
+    const c = await wrapped.connect();
+    expect(c.escapeIdentifier('x')).toBe('"x"');
+    expect(client.escapeIdentifier).toHaveBeenCalledWith('x');
+  });
+});
+
+// =============================================================================
+// Wrapper: identity mode (canonical tenant querying itself)
+// =============================================================================
+
+describe('createRewritingPool — identity mode', () => {
+  it('leaves text and prepared names untouched when the tenant is canonical', async () => {
+    const { client, counters, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery([CANON_APP, CANON_AUTH, 'public']));
+
+    await c.query({ text: `select from "${CANON_APP}"."t"`, name: 'p1' });
+    expect(sentText(client, 1)).toBe(`select from "${CANON_APP}"."t"`);
+    expect(client.query.mock.calls[1][0].name).toBe('p1');
+    expect(counters.rewrittenQueries).toBe(0);
+    expect(counters.nameRewrites).toBe(0);
+  });
+});
+
+// =============================================================================
+// Wrapper: prepared-statement name namespacing
+// =============================================================================
+
+describe('createRewritingPool — prepared name namespacing', () => {
+  it('is deterministic per tenant and differs across tenants', async () => {
+    const a = setup();
+    const ca = await a.wrapped.connect();
+    await ca.query(settingsQuery(tenantSchemas));
+    await ca.query({ text: 'select 1', name: 'stmt' });
+    await ca.query({ text: 'select 2', name: 'stmt' });
+    const nameA1 = a.client.query.mock.calls[1][0].name;
+    const nameA2 = a.client.query.mock.calls[2][0].name;
+    expect(nameA1).toMatch(/^bp_[0-9a-f]{24}$/);
+    expect(nameA2).toBe(nameA1); // same tenant + original name => same
+
+    const b = setup();
+    const cb = await b.wrapped.connect();
+    await cb.query(settingsQuery(['app-33333333-app-public', 'app-33333333-auth-public', 'public']));
+    await cb.query({ text: 'select 1', name: 'stmt' });
+    const nameB1 = b.client.query.mock.calls[1][0].name;
+    expect(nameB1).not.toBe(nameA1); // different tenant => different name
+  });
+});
+
+// =============================================================================
+// Wrapper: prepared-statement lifecycle (the wrapper owns eviction + DEALLOCATE)
+// =============================================================================
+
+describe('createRewritingPool — prepared-statement lifecycle', () => {
+  // The `deallocate "bp_…"` statements the raw client received, in order.
+  const deallocs = (client: ReturnType<typeof makeClient>): string[] =>
+    client.query.mock.calls
+      .map((call: any[]) => call[0])
+      .filter((arg: any): arg is string => typeof arg === 'string' && arg.startsWith('deallocate'));
+
+  it('passes DEALLOCATE text through untouched (adaptor concern, not ours)', async () => {
+    const { client, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    await c.query('deallocate stmt');
+    await c.query('deallocate all');
+    expect(sentText(client, 1)).toBe('deallocate stmt');
+    expect(sentText(client, 2)).toBe('deallocate all');
+  });
+
+  it('evicts the oldest hashed name and deallocates it once the cap is exceeded', async () => {
+    const { client, wrapped } = setup({ maxPreparedNames: 2 });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    await c.query({ text: 'select 1', name: 'a' });
+    await c.query({ text: 'select 2', name: 'b' });
+    const hashedA = client.query.mock.calls[1][0].name;
+    expect(hashedA).toMatch(/^bp_[0-9a-f]{24}$/);
+
+    await c.query({ text: 'select 3', name: 'c' }); // 3rd distinct name -> evict 'a'
+
+    expect(deallocs(client)).toEqual([`deallocate "${hashedA}"`]);
+  });
+
+  it('clears node-postgres parsedStatements bookkeeping for the evicted name', async () => {
+    const { client, wrapped } = setup({ maxPreparedNames: 2 });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    await c.query({ text: 'select 1', name: 'a' });
+    const hashedA = client.query.mock.calls[1][0].name;
+    // Simulate node-postgres having parsed/prepared under the hashed name.
+    (client as any).connection = { parsedStatements: { [hashedA]: 'select 1' } };
+
+    await c.query({ text: 'select 2', name: 'b' });
+    await c.query({ text: 'select 3', name: 'c' }); // evict 'a'
+    await new Promise((resolve) => setImmediate(resolve)); // flush the fire-and-forget then()
+
+    // Without this cleanup, re-preparing 'a' would skip Parse and fail on PG
+    // with "prepared statement does not exist".
+    expect((client as any).connection.parsedStatements[hashedA]).toBeUndefined();
+  });
+
+  it('refreshes recency: re-touching name 1 evicts name 2 instead', async () => {
+    const { client, wrapped } = setup({ maxPreparedNames: 2 });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    await c.query({ text: 'select 1', name: 'a' }); // [a]
+    await c.query({ text: 'select 2', name: 'b' }); // [a, b]
+    const hashedA = client.query.mock.calls[1][0].name;
+    const hashedB = client.query.mock.calls[2][0].name;
+
+    await c.query({ text: 'select 1 again', name: 'a' }); // refresh a -> [b, a]
+    await c.query({ text: 'select 3', name: 'c' }); // insert c -> evict b
+
+    expect(deallocs(client)).toEqual([`deallocate "${hashedB}"`]);
+    expect(deallocs(client)).not.toContain(`deallocate "${hashedA}"`);
+  });
+
+  it('re-using the same name neither grows the LRU nor deallocates', async () => {
+    const { client, wrapped } = setup({ maxPreparedNames: 2 });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    await c.query({ text: 'select 1', name: 'a' });
+    await c.query({ text: 'select 1 v2', name: 'a' });
+    await c.query({ text: 'select 1 v3', name: 'a' });
+
+    expect(deallocs(client)).toEqual([]);
+  });
+
+  it('keeps the prepared-name LRU across release (it lives on the physical connection)', async () => {
+    const { client, wrapped } = setup({ maxPreparedNames: 2 });
+
+    const c1 = await wrapped.connect();
+    await c1.query(settingsQuery(tenantSchemas));
+    await c1.query({ text: 'select 1', name: 'a' }); // [a]
+    const hashedA = client.query.mock.calls[1][0].name;
+    c1.release();
+
+    // Same physical client returns; tenant state reset, prepared-name LRU intact.
+    const c2 = await wrapped.connect();
+    await c2.query(settingsQuery(tenantSchemas));
+    await c2.query({ text: 'select 2', name: 'b' }); // [a, b]
+    await c2.query({ text: 'select 3', name: 'c' }); // evict a (survived release)
+
+    expect(deallocs(client)).toEqual([`deallocate "${hashedA}"`]);
+  });
+
+  it('honors DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE for the default cap', async () => {
+    const original = process.env.DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE;
+    process.env.DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE = '1';
+    try {
+      const { client, wrapped } = setup(); // no explicit maxPreparedNames
+      const c = await wrapped.connect();
+      await c.query(settingsQuery(tenantSchemas));
+
+      await c.query({ text: 'select 1', name: 'a' });
+      const hashedA = client.query.mock.calls[1][0].name;
+      await c.query({ text: 'select 2', name: 'b' }); // cap 1 -> evict a
+
+      expect(deallocs(client)).toEqual([`deallocate "${hashedA}"`]);
+    } finally {
+      if (original === undefined) delete process.env.DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE;
+      else process.env.DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE = original;
+    }
+  });
+});
+
+// =============================================================================
+// Wrapper: fail-closed
+// =============================================================================
+
+describe('createRewritingPool — fail closed', () => {
+  it('rejects a rewrite-needing query issued before any settings query', async () => {
+    const { client, counters, wrapped } = setup();
+    const c = await wrapped.connect();
+
+    await expect(c.query({ text: `select from "${CANON_APP}"."t"` })).rejects.toThrow(
+      /requires a tenant mapping but none is established/
+    );
+    expect(counters.failClosed).toBe(1);
+    expect(client.query).not.toHaveBeenCalled();
+  });
+
+  it('passes benign non-rewrite statements through untouched', async () => {
+    const { client, counters, wrapped } = setup();
+    const c = await wrapped.connect();
+
+    await c.query('begin');
+    await c.query({ text: 'listen "x"' });
+    await c.query({ text: 'select 1 from pg_catalog.pg_class' });
+    await c.query({ text: 'select set_config($1,$2,true)', values: ['role', 'app_user'] });
+
+    expect(counters.failClosed).toBe(0);
+    expect(client.query.mock.calls.map((call: any[]) => call[0])).toEqual([
+      'begin',
+      { text: 'listen "x"' },
+      { text: 'select 1 from pg_catalog.pg_class' },
+      { text: 'select set_config($1,$2,true)', values: ['role', 'app_user'] }
+    ]);
+  });
+
+  it('fails closed with a callback when called callback-style', async () => {
+    const { wrapped } = setup();
+    const c = await wrapped.connect();
+    const err: Error = await new Promise((resolve) => {
+      c.query({ text: `select from "${CANON_APP}"."t"` }, (e: Error) => resolve(e));
+    });
+    expect(err.message).toMatch(/requires a tenant mapping/);
+  });
+});
+
+// =============================================================================
+// Wrapper: settings detection keys on the adaptor statement TEXT, not on
+// user-influenceable parameter contents (A1 — misclassification hardening).
+// =============================================================================
+
+describe('createRewritingPool — settings detection is text-gated', () => {
+  it('does not misclassify a data query as settings when a bind value contains the GUC substring', async () => {
+    const { client, counters, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+    expect(counters.settingsParses).toBe(1);
+
+    // A genuine data query whose user-controlled bind value contains the GUC
+    // string. Under parameter-only detection this was treated as the settings
+    // query and forwarded UNREWRITTEN (canonical SQL on the tenant connection).
+    await c.query({
+      text: `select from "${CANON_APP}"."t" where x = $1`,
+      values: [`${POOL_SCHEMAS_GUC} = whatever`]
+    });
+
+    // Rewritten to the tenant schema — not forwarded with canonical identifiers.
+    expect(sentText(client, 1)).toBe(`select from "${TENANT_APP}"."t" where x = $1`);
+    // The malicious value was NOT parsed as settings; checkout map is intact.
+    expect(counters.settingsParses).toBe(1);
+  });
+
+  it('a GUC-substring bind value cannot null the established tenant map (no self-DoS)', async () => {
+    const { client, counters, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    // Malicious non-JSON value that, under parameter-only detection, would have
+    // re-run applySettings and nulled tenantMap (forcing later fail-closed).
+    await c.query({
+      text: `select from "${CANON_APP}"."t"`,
+      values: [`${POOL_SCHEMAS_GUC}: not json`]
+    });
+    expect(sentText(client, 1)).toBe(`select from "${TENANT_APP}"."t"`);
+
+    // Sibling query still rewrites (map not clobbered) rather than failing closed.
+    await c.query({ text: `select from "${CANON_AUTH}"."r"` });
+    expect(sentText(client, 2)).toBe(`select from "${TENANT_AUTH}"."r"`);
+    expect(counters.failClosed).toBe(0);
+    expect(counters.settingsParses).toBe(1);
+  });
+
+  it('a crafted GUC-bearing JSON bind value cannot remap the checkout to another tenant', async () => {
+    const { client, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas)); // maps canonical -> app-22222222
+
+    const victim = ['app-99999999-app-public', 'app-99999999-auth-public', 'public'];
+    // Same value shape the real settings query would carry, but on a DATA query.
+    await c.query({
+      text: `select from "${CANON_APP}"."t"`,
+      values: [JSON.stringify([[POOL_SCHEMAS_GUC, JSON.stringify(victim)]])]
+    });
+
+    // Still the original tenant (22222222), never the injected victim (99999999).
+    expect(sentText(client, 1)).toBe(`select from "${TENANT_APP}"."t"`);
+  });
+
+  it('fails closed (does not swallow as settings) for a pre-settings query carrying a GUC value', async () => {
+    const { client, counters, wrapped } = setup();
+    const c = await wrapped.connect();
+
+    await expect(
+      c.query({ text: `select from "${CANON_APP}"."t"`, values: [`${POOL_SCHEMAS_GUC} x`] })
+    ).rejects.toThrow(/requires a tenant mapping/);
+    expect(counters.failClosed).toBe(1);
+    expect(counters.settingsParses).toBe(0);
+    expect(client.query).not.toHaveBeenCalled();
+  });
+});
+
+// =============================================================================
+// Wrapper: release clears state
+// =============================================================================
+
+describe('createRewritingPool — release clears state', () => {
+  it('re-checkout of the same client requires a fresh settings query', async () => {
+    const { client, wrapped } = setup();
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+    await c.query({ text: `select from "${CANON_APP}"."t"` }); // ok
+
+    c.release();
+    expect(client.release).toHaveBeenCalled();
+
+    await expect(c.query({ text: `select from "${CANON_APP}"."t"` })).rejects.toThrow(
+      /requires a tenant mapping/
+    );
+  });
+});
+
+// =============================================================================
+// Wrapper: logical mismatch => invalid checkout
+// =============================================================================
+
+describe('createRewritingPool — logical mismatch', () => {
+  it('marks the checkout invalid and fails closed with the reason', async () => {
+    const { counters, wrapped } = setup();
+    const c = await wrapped.connect();
+    // Tenant list is missing an auth-public counterpart.
+    await c.query(settingsQuery([TENANT_APP, 'public']));
+
+    await expect(c.query({ text: `select from "${CANON_AUTH}"."t"` })).rejects.toThrow(
+      /auth-public/
+    );
+    expect(counters.failClosed).toBe(1);
+  });
+});
+
+// =============================================================================
+// Wrapper: LRU memo cap
+// =============================================================================
+
+describe('createRewritingPool — LRU memo cap', () => {
+  it('respects the cap while keeping every rewrite correct', async () => {
+    const { client, counters, wrapped } = setup({ maxMemoEntries: 2 });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    const q1 = { text: `select from "${CANON_APP}"."a"` };
+    const q2 = { text: `select from "${CANON_APP}"."b"` };
+    const q3 = { text: `select from "${CANON_APP}"."c"` };
+
+    await c.query(q1);
+    await c.query(q2);
+    await c.query(q3); // fills then evicts q1 (cap 2)
+    expect(counters.memoHits).toBe(0);
+
+    await c.query(q1); // q1 was evicted => miss (proves the cap held)
+    expect(counters.memoHits).toBe(0);
+
+    await c.query(q3); // q3 still cached => hit
+    expect(counters.memoHits).toBe(1);
+
+    // Every rewrite stayed correct regardless of eviction.
+    expect(sentText(client, 1)).toBe(`select from "${TENANT_APP}"."a"`);
+    expect(sentText(client, 3)).toBe(`select from "${TENANT_APP}"."c"`);
+    expect(sentText(client, 4)).toBe(`select from "${TENANT_APP}"."a"`);
+    expect(sentText(client, 5)).toBe(`select from "${TENANT_APP}"."c"`);
+  });
+});
+
+// =============================================================================
+// Wrapper: counters
+// =============================================================================
+
+describe('createRewritingPool — counters', () => {
+  it('increments each counter exactly as specified', async () => {
+    const { wrapped, counters } = setup();
+    const c = await wrapped.connect();
+
+    await c.query(settingsQuery(tenantSchemas)); // settingsParses
+    await c.query({ text: `select from "${CANON_APP}"."t"` }); // rewrittenQueries (miss)
+    await c.query({ text: `select from "${CANON_APP}"."t"` }); // rewrittenQueries + memoHits
+    await c.query({ text: 'select 1', name: 'p1' }); // nameRewrites
+
+    const expected: RewriteCounters = {
+      settingsParses: 1,
+      rewrittenQueries: 2,
+      memoHits: 1,
+      failClosed: 0,
+      nameRewrites: 1
+    };
+    expect(counters).toEqual(expected);
+  });
+
+  it('shares a caller-provided counters object', async () => {
+    const counters = createRewriteCounters();
+    const { wrapped } = setup({ counters });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+    expect(counters.settingsParses).toBe(1);
+  });
+
+  it('feeds the process-wide getRewritePoolCounters() snapshot when no counters are passed', async () => {
+    const before = getRewritePoolCounters().settingsParses;
+    // No explicit counters -> activity lands in the module-level sink.
+    const client = makeClient();
+    const wrapped = createRewritingPool(makePool(client), { canonicalSchemas, logicalName });
+    const c = await wrapped.connect();
+    await c.query(settingsQuery(tenantSchemas));
+
+    expect(getRewritePoolCounters().settingsParses).toBe(before + 1);
+    // Returns a snapshot copy, not the live object.
+    const snap = getRewritePoolCounters();
+    snap.settingsParses = -999;
+    expect(getRewritePoolCounters().settingsParses).toBe(before + 1);
+  });
+});
+
+// =============================================================================
+// Pool-level one-shot query
+// =============================================================================
+
+describe('createRewritingPool — pool.query one-shot', () => {
+  it('passes benign queries through and fails closed on rewrite-needing ones', async () => {
+    const { pool, wrapped } = setup();
+
+    await wrapped.query('select 1');
+    expect(pool.query).toHaveBeenCalledWith('select 1');
+
+    await expect(wrapped.query({ text: `select from "${CANON_APP}"."t"` })).rejects.toThrow(
+      /requires a tenant mapping/
+    );
+  });
+});
diff --git a/graphql/server/src/middleware/__tests__/settings-text-pin.test.ts b/graphql/server/src/middleware/__tests__/settings-text-pin.test.ts
new file mode 100644
index 0000000000..ebc706a689
--- /dev/null
+++ b/graphql/server/src/middleware/__tests__/settings-text-pin.test.ts
@@ -0,0 +1,24 @@
+import { readFileSync } from 'fs';
+
+import { SETTINGS_QUERY_TEXT } from '../rewrite-pool';
+
+/**
+ * Pins SETTINGS_QUERY_TEXT against the INSTALLED @dataplan/pg adaptor source.
+ *
+ * The rewriting pool classifies the adaptor's pgSettings statement by exact
+ * text equality (defense against user bind values that merely contain the
+ * pool_schemas GUC substring). If a dependency bump changes the emitted
+ * statement, classification silently stops matching: applySettings never runs,
+ * no checkout ever gets a tenant mapping, and every pooled data query fails
+ * closed. That is the SAFE direction, but it disables pooling entirely and
+ * only surfaces at runtime — this test makes the drift fail loudly here
+ * instead. Mirrors the pg-introspection pinning approach in
+ * introspection-filter.test.ts.
+ */
+describe('SETTINGS_QUERY_TEXT pins the installed @dataplan/pg adaptor', () => {
+  it('the adaptor source still emits the exact statement we byte-match', () => {
+    const adaptorPath = require.resolve('@dataplan/pg/adaptors/pg');
+    const source = readFileSync(adaptorPath, 'utf8');
+    expect(source).toContain(SETTINGS_QUERY_TEXT);
+  });
+});
diff --git a/graphql/server/src/middleware/api.ts b/graphql/server/src/middleware/api.ts
index 005be581fd..cd20402413 100644
--- a/graphql/server/src/middleware/api.ts
+++ b/graphql/server/src/middleware/api.ts
@@ -14,6 +14,7 @@ import { getPgPool } from 'pg-cache';
 import errorPage50x from '../errors/50x';
 import errorPage404Message from '../errors/404-message';
 import { ApiConfigResult, ApiError, ApiOptions, ApiStructure, AuthSettings, DatabaseSettings, PubkeyChallengeSettings, RlsModule, WebauthnSettings } from '../types';
+import { stripSchemaHashPrefix } from './blueprint';
 import './types';
 
 const log = new Logger('api');
@@ -266,6 +267,7 @@ const toApiStructure = (row: ApiRow, opts: ApiOptions, settings: ResolvedModuleS
   anonRole: row.anon_role || 'anon',
   roleName: row.role_name || 'authenticated',
   schema: row.schemas || [],
+  logicalSchemas: (row.schemas || []).map(stripSchemaHashPrefix),
   apiModules: [],
   rlsModule: settings.rlsModule,
   domains: [],
diff --git a/graphql/server/src/middleware/blueprint.ts b/graphql/server/src/middleware/blueprint.ts
new file mode 100644
index 0000000000..71984ba30d
--- /dev/null
+++ b/graphql/server/src/middleware/blueprint.ts
@@ -0,0 +1,129 @@
+import { createHash } from 'node:crypto';
+import type { Pool } from 'pg';
+
+// =============================================================================
+// Blueprint pooling identity helpers
+//
+// OPT-IN "blueprint pooling" shares one PostGraphile instance per schema-shape.
+// Tenants are routed per request by the rewriting pool (canonical→tenant schema-
+// identifier rewrite; see ./rewrite-pool). These helpers derive the identity of a
+// shared instance (shape fingerprint + blueprint key).
+// =============================================================================
+
+/**
+ * Whether blueprint pooling is enabled via the GRAPHILE_BLUEPRINT_POOLING env
+ * flag. Accepts '1' or 'true'; anything else (incl. unset) means disabled.
+ */
+export const isBlueprintPoolingEnabled = (): boolean => {
+  const value = process.env.GRAPHILE_BLUEPRINT_POOLING;
+  return value === '1' || value === 'true';
+};
+
+/**
+ * Strip the tenant hash prefix from a physical schema name.
+ *
+ * Tenant physical schemas look like `<dashed-dbname>-<8hex>-<logical>`, e.g.
+ * `marketplace-db-tenant1-5e6b13b2-app-public` -> `app-public`. We strip through
+ * the FIRST `-<8 lowercase hex>-` occurrence and return the remainder. Control
+ * plane schemas (e.g. `services_public`) contain no such segment and are
+ * returned unchanged.
+ */
+export const stripSchemaHashPrefix = (name: string): string => {
+  const match = /-[0-9a-f]{8}-/.exec(name);
+  if (!match) return name;
+  return name.slice(match.index + match[0].length);
+};
+
+export interface SchemaRelation {
+  nspname: string;
+  relname: string;
+}
+
+/**
+ * Single catalog scan backing the shape fingerprint.
+ */
+export const fetchSchemaRelations = async (
+  pool: Pool,
+  physicalSchemas: string[]
+): Promise<SchemaRelation[]> => {
+  const result = await pool.query<SchemaRelation>(
+    `SELECT n.nspname, c.relname
+     FROM pg_class c
+     JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE n.nspname = ANY($1) AND c.relkind IN ('r','v','m','p')
+     ORDER BY 1, 2`,
+    [physicalSchemas]
+  );
+  return result.rows;
+};
+
+/**
+ * Pure fingerprint over pre-fetched relations: sha256 of the sorted
+ * `[logicalSchema, relname]` pairs (physical names mapped to logical form so
+ * same-shape tenants collapse to the same fingerprint).
+ *
+ * NOTE (v1 granularity): the fingerprint covers relation NAMES only — not
+ * columns, functions or enum labels. Same-relname column drift between tenants
+ * is not detected here; it is bounded by flushService's flush-all-pooled-on-
+ * schema:update semantics. Extending the fingerprint to attributes/procs is a
+ * documented follow-up.
+ */
+export const fingerprintFromRelations = (rows: SchemaRelation[]): string => {
+  const pairs: [string, string][] = rows.map((row) => [
+    stripSchemaHashPrefix(row.nspname),
+    row.relname
+  ]);
+  pairs.sort((a, b) => {
+    if (a[0] !== b[0]) return a[0] < b[0] ? -1 : 1;
+    if (a[1] !== b[1]) return a[1] < b[1] ? -1 : 1;
+    return 0;
+  });
+  return createHash('sha256').update(JSON.stringify(pairs)).digest('hex');
+};
+
+/**
+ * Compute a fingerprint of the relational shape shared by a set of physical
+ * schemas. Physical schema names are mapped to their logical form (hash prefix
+ * stripped) so that different tenants of the same shape collapse to the same
+ * fingerprint. The fingerprint is a sha256 hex digest over the sorted
+ * `[logicalSchema, relname]` pairs.
+ */
+export const computeShapeFingerprint = async (
+  pool: Pool,
+  physicalSchemas: string[]
+): Promise<string> => fingerprintFromRelations(await fetchSchemaRelations(pool, physicalSchemas));
+
+/**
+ * Compute the stable blueprint key that identifies a poolable PostGraphile
+ * instance. Two requests share an instance iff they agree on logical schemas,
+ * shape fingerprint, gather/schema flags, api name and mode. Inputs are
+ * normalized (schemas sorted, flag entries sorted by key) so the key is
+ * independent of ordering.
+ */
+export const computeBlueprintKey = (input: {
+  logicalSchemas: string[];
+  shapeFingerprint: string;
+  flags: Record<string, any> | undefined;
+  apiName?: string | null;
+  mode: string;
+  /**
+   * Physical database backing the instance's pool. REQUIRED for correctness in
+   * multi-database fleets: without it, same-shape tenants living in DIFFERENT
+   * physical databases would share one instance whose pool points at only one
+   * of them.
+   */
+  dbname?: string | null;
+}): string => {
+  const payload = {
+    s: [...input.logicalSchemas].sort(),
+    f: input.shapeFingerprint,
+    g: Object.entries(input.flags || {}).sort((a, b) =>
+      a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0
+    ),
+    a: input.apiName || '',
+    m: input.mode,
+    d: input.dbname || ''
+  };
+
+  return 'bp:' + createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+};
diff --git a/graphql/server/src/middleware/flush.ts b/graphql/server/src/middleware/flush.ts
index 653d74631c..70b7bc8a72 100644
--- a/graphql/server/src/middleware/flush.ts
+++ b/graphql/server/src/middleware/flush.ts
@@ -2,9 +2,11 @@ import { ConstructiveOptions } from '@constructive-io/graphql-types';
 import { Logger } from '@pgpmjs/logger';
 import { svcCache } from '@pgpmjs/server-utils';
 import { NextFunction, Request, Response } from 'express';
-import { graphileCache } from 'graphile-cache';
+import { clearMatchingEntries, graphileCache } from 'graphile-cache';
 import { getPgPool } from 'pg-cache';
 import './types'; // for Request type
+import { isBlueprintPoolingEnabled } from './blueprint';
+import { clearPoolDecisions, clearPoolDecisionsForDatabase } from './pooling-decision';
 
 const log = new Logger('flush');
 
@@ -17,6 +19,12 @@ export const flush = async (
     // TODO: check bearer for a flush / special key
     graphileCache.delete((req as any).svc_key);
     svcCache.delete((req as any).svc_key);
+    // Under pooling the serving instance is stored under a `bp:` key, which the
+    // svc_key delete above cannot reach — mirror flushService's v1 semantics.
+    if (isBlueprintPoolingEnabled()) {
+      clearMatchingEntries(/^bp:/);
+      clearPoolDecisions();
+    }
     res.status(200).send('OK');
     return;
   }
@@ -30,6 +38,23 @@ export const flushService = async (
   const pgPool = getPgPool(opts.pg);
   log.info('flushing db ' + databaseId);
 
+  // Blueprint pooling: invalidate ONLY the changed database's decisions and the
+  // blueprint instance it was attached to. Fleet-wide `bp:` flushes on every
+  // schema:update turned each tenant PROVISION into a cold restart of every
+  // pooled instance — and the immediate rebuild raced the evicted instances'
+  // drain (~GB still live until release), which OOMed the 24h soak. New tenants
+  // have no memoized decisions, so provisioning is a no-op here (instances are
+  // shape-generic; a same-shape tenant attaches without any rebuild).
+  if (isBlueprintPoolingEnabled()) {
+    const bpKeys = clearPoolDecisionsForDatabase(databaseId);
+    for (const key of bpKeys) {
+      graphileCache.delete(key);
+    }
+    if (bpKeys.length > 0) {
+      log.info(`[pooling] flushed ${bpKeys.length} blueprint(s) for db ${databaseId}: ${bpKeys.join(', ')}`);
+    }
+  }
+
   const api = new RegExp(`^api:${databaseId}:.*`);
   const schemata = new RegExp(`^schemata:${databaseId}:.*`);
   const meta = new RegExp(`^metaschema:api:${databaseId}`);
diff --git a/graphql/server/src/middleware/graphile.ts b/graphql/server/src/middleware/graphile.ts
index 477e61288b..fe7ed33b9d 100644
--- a/graphql/server/src/middleware/graphile.ts
+++ b/graphql/server/src/middleware/graphile.ts
@@ -3,19 +3,44 @@ import { getNodeEnv } from '@pgpmjs/env';
 import type { ConstructiveOptions } from '@constructive-io/graphql-types';
 import { Logger } from '@pgpmjs/logger';
 import type { NextFunction, Request, RequestHandler, Response } from 'express';
-import type { GraphQLError, GraphQLFormattedError } from 'grafast/graphql';
-import { createGraphileInstance, type GraphileCacheEntry, graphileCache } from 'graphile-cache';
+// Type-only import of the canonical GraphQL error types. Imported from 'graphql'
+// (a direct, version-pinned dependency) rather than the 'grafast/graphql' subpath so
+// the types resolve under every moduleResolution mode — including ts-jest, which type-
+// checks this file transitively via the diagnostics metrics sampler. Erased at runtime.
+import type { GraphQLError, GraphQLFormattedError } from 'graphql';
+import type { Pool } from 'pg';
+import {
+  createGraphileInstance,
+  ensureCacheHeadroom,
+  getMemoryPressure,
+  type GraphileCacheEntry,
+  graphileCache,
+  invokeEntryHandler,
+  shouldRefuseBuild,
+  waitForDrainSettle,
+} from 'graphile-cache';
 import type { GraphileConfig } from 'graphile-config';
 import { createConstructivePreset, makePgService } from 'graphile-settings';
 import { getPgPool } from 'pg-cache';
 import { getPgEnvOptions } from 'pg-env';
 import './types'; // for Request type
+import { isBlueprintPoolingEnabled, stripSchemaHashPrefix } from './blueprint';
+import { resolvePoolDecision } from './pooling-decision';
+import {
+  createIntrospectionFilterPool,
+  isIntrospectionFilterEnabled
+} from './introspection-filter';
+import { createRewritingPool, POOL_SCHEMAS_GUC } from './rewrite-pool';
 import { isGraphqlObservabilityEnabled } from '../diagnostics/observability';
 import { HandlerCreationError } from '../errors/api-errors';
 import { observeGraphileBuild } from './observability/graphile-build-stats';
 import type { DatabaseSettings } from '../types';
 import { AuthCookiePlugin } from '../plugins/auth-cookie-plugin';
 
+// Re-exported so flush.ts (and other callers) can invalidate pooling decisions
+// through the graphile module surface.
+export { clearPoolDecisions } from './pooling-decision';
+
 const maskErrorLog = new Logger('graphile:maskError');
 
 const SAFE_ERROR_CODES = new Set([
@@ -191,6 +216,101 @@ export function clearInFlightMap(): void {
   creating.clear();
 }
 
+/**
+ * Seeds an in-flight creation promise for a key. Used for testing purposes to
+ * exercise the coalescing paths (Phase B / Phase C re-coalesce) deterministically.
+ */
+export function setInFlightForTest(key: string, promise: Promise<GraphileCacheEntry>): void {
+  creating.set(key, promise);
+}
+
+// =============================================================================
+// Build Admission Control
+// =============================================================================
+
+/**
+ * Bounds how many PostGraphile schema builds run concurrently across ALL cache
+ * keys (the single-flight map only dedups builds for the SAME key). Each build
+ * transiently allocates hundreds of MB, so concurrent builds of different
+ * tenants stack those peaks on top of the resident cache — the OOM shape.
+ * Default 1: builds queue and run serially. Override with GRAPHILE_BUILD_CONCURRENCY.
+ */
+class BuildSemaphore {
+  private active = 0;
+  private waiters: Array<() => void> = [];
+  constructor(private readonly capacity: number) {}
+
+  async acquire(): Promise<void> {
+    if (this.active < this.capacity) {
+      this.active++;
+      return;
+    }
+    await new Promise<void>((resolve) => this.waiters.push(resolve));
+    this.active++;
+  }
+
+  release(): void {
+    this.active = Math.max(0, this.active - 1);
+    const wake = this.waiters.shift();
+    if (wake) wake();
+  }
+
+  /** Number of builds currently queued (blocked on a free slot). */
+  get queueDepth(): number {
+    return this.waiters.length;
+  }
+}
+
+const parseBuildConcurrency = (): number => {
+  const raw = process.env.GRAPHILE_BUILD_CONCURRENCY;
+  const n = raw ? parseInt(raw, 10) : 1;
+  return Number.isFinite(n) && n > 0 ? n : 1;
+};
+
+const buildSemaphore = new BuildSemaphore(parseBuildConcurrency());
+
+/**
+ * Returns the number of PostGraphile schema builds currently queued behind the
+ * build-concurrency semaphore. A persistently non-zero depth means builds are
+ * arriving faster than they can be serialized — a leading indicator of build
+ * backpressure under load. Exposed for the metrics sampler.
+ */
+export function getBuildQueueDepth(): number {
+  return buildSemaphore.queueDepth;
+}
+
+// =============================================================================
+// In-Process Build Counters (metrics)
+// =============================================================================
+
+export interface GraphileCounters {
+  /** Total PostGraphile schema builds started (past coalescing + the semaphore). */
+  builds: number;
+  /** Requests routed to a shared blueprint (pooling) instance. */
+  poolingAttaches: number;
+  /** Builds that were pooled (shared-blueprint) builds. */
+  poolingBuilds: number;
+  /** Requests that gave up waiting on a build (GRAPHILE_BUILD_TIMEOUT_MS) and got 503. */
+  buildWaitTimeouts: number;
+}
+
+/**
+ * Cumulative in-process build counters for the metrics sampler. Mutated where a build
+ * starts and where a [pooling] attach/build happens. Zero overhead when the sampler is
+ * off — these are integer bumps on paths that already do real build work.
+ */
+const graphileCounters: GraphileCounters = {
+  builds: 0,
+  poolingAttaches: 0,
+  poolingBuilds: 0,
+  buildWaitTimeouts: 0
+};
+
+/** Snapshot the build counters. Returns a copy so callers cannot mutate live state. */
+export function getGraphileCounters(): GraphileCounters {
+  return { ...graphileCounters };
+}
+
 const log = new Logger('graphile');
 const reqLabel = (req: Request): string => (req.requestId ? `[${req.requestId}]` : '[req]');
 
@@ -203,25 +323,52 @@ const reqLabel = (req: Request): string => (req.requestId ? `[${req.requestId}]`
  * (everything on except aggregates).
  */
 const buildPreset = (
-  pool: import('pg').Pool,
+  pool: Pool,
   schemas: string[],
   anonRole: string,
   roleName: string,
   databaseSettings?: DatabaseSettings,
+  options?: { pooling?: boolean },
 ): GraphileConfig.Preset => {
-  return {
+  // When pooling, the instance is shared across tenants of the same schema-shape
+  // and routed per request via the rewriting pool (canonical→tenant schema-
+  // identifier rewrite; see ./rewrite-pool).
+  const pooling = options?.pooling === true;
+  // Pooled instances are built fully qualified against the canonical tenant's
+  // physical schemas; the rewriting pool swaps canonical→tenant schema
+  // identifiers per request (see ./rewrite-pool). Dedicated instances use the
+  // raw pool untouched.
+  // Introspection filter (opt-in via GRAPHILE_INTROSPECTION_FILTER): scope the
+  // instance's catalog introspection to the schemas it serves. Only active when
+  // the flag is on AND we have a concrete served-schema list; otherwise the pool
+  // selection below is byte-identical to today. Pooled instances receive the
+  // filter through the rewriting pool; dedicated instances get a thin filter-only
+  // wrapper on the raw pool.
+  const introspectionFilterActive = isIntrospectionFilterEnabled() && schemas.length > 0;
+  const servicePool = pooling
+    ? createRewritingPool(pool, {
+        canonicalSchemas: schemas,
+        logicalName: stripSchemaHashPrefix,
+        introspectionFilter: introspectionFilterActive ? { servedSchemas: schemas } : false
+      })
+    : introspectionFilterActive
+      ? createIntrospectionFilterPool(pool, { servedSchemas: schemas })
+      : pool;
+  const preset: GraphileConfig.Preset = {
   extends: [createConstructivePreset(databaseSettings)],
   plugins: [AuthCookiePlugin],
   pgServices: [
     makePgService({
-      pool,
+      pool: servicePool,
       schemas,
     }),
   ],
   grafserv: {
     graphqlPath: '/graphql',
     graphiqlPath: '/graphiql',
-    graphiql: true,
+    // GraphiQL (ruru) assets/handlers are per-instance overhead and an unnecessary
+    // prod surface — enable only in development, or explicitly via GRAPHILE_GRAPHIQL=true.
+    graphiql: getNodeEnv() === 'development' || process.env.GRAPHILE_GRAPHIQL === 'true',
     graphiqlOnGraphQLGET: false,
     maskError,
   },
@@ -232,6 +379,13 @@ const buildPreset = (
       const req = (requestContext as { expressv4?: { req?: Request } })?.expressv4?.req;
       const context: Record<string, string> = {};
 
+      // De-closure the role names: read them from the resolved API on the request
+      // so a shared (pooled) instance uses the REQUESTING tenant's roles rather than
+      // whichever tenant happened to build it. Falls back to the build-time params.
+      const api = req?.api;
+      const role = api?.roleName ?? roleName;
+      const anon = api?.anonRole ?? anonRole;
+
       if (req) {
         if (req.databaseId) {
           context['jwt.claims.database_id'] = req.databaseId;
@@ -251,7 +405,7 @@ const buildPreset = (
 
         if (req.token?.user_id) {
           const pgSettings: Record<string, string> = {
-            role: roleName,
+            role,
             'jwt.claims.token_id': req.token.id,
             'jwt.claims.user_id': req.token.user_id,
             ...context,
@@ -282,29 +436,110 @@ const buildPreset = (
             pgSettings['request.id'] = req.requestId;
           }
 
+          // Pooled instances: hand the REQUESTING tenant's physical schema list to
+          // the rewriting pool via a transaction-local GUC; the wrapper maps the
+          // canonical schemas to these by logical name. Never set when not pooling.
+          if (pooling && api?.schema?.length) {
+            pgSettings[POOL_SCHEMAS_GUC] = JSON.stringify(api.schema);
+          }
+
           return { pgSettings };
         }
       }
 
       const anonSettings: Record<string, string> = {
-        role: anonRole,
+        role: anon,
         ...context,
       };
       if (req?.requestId) {
         anonSettings['request.id'] = req.requestId;
       }
+      // Pooled instances: hand the REQUESTING tenant's physical schema list to
+      // the rewriting pool via a transaction-local GUC; the wrapper maps the
+      // canonical schemas to these by logical name. Never set when not pooling.
+      if (pooling && api?.schema?.length) {
+        anonSettings[POOL_SCHEMAS_GUC] = JSON.stringify(api.schema);
+      }
 
       return {
         pgSettings: anonSettings,
       };
     },
   },
+  };
+
+  if (pooling) {
+    // Shared (pooled) instances must not leak the canonical tenant's hashed
+    // schema names through tenant-facing metadata (e.g. _meta) — plugins read
+    // this flag and report logical schema names instead. SQL emission stays
+    // fully qualified (PostGraphile default). Cast: custom schema option,
+    // absent from base types.
+    (preset as any).schema = { constructivePooled: true };
+  }
+
+  return preset;
 };
+
+/**
+ * Bound how long a REQUEST waits on a build, ALWAYS clearing the timeout timer.
+ *
+ * The build itself is not cancelled — makeSchema cannot be aborted — it completes
+ * in the background and fills the cache for retries. Resolves to the built value
+ * when the build wins, or `null` when the wait expires.
+ *
+ * Why the finally/clearTimeout is load-bearing: `Promise.race` subscribes reactions
+ * to BOTH arms. If the timeout timer is left armed after the build wins, Node's
+ * internal timers list keeps the timeout arm's reaction — and, transitively through
+ * the race result promise, the built ~15MB instance — reachable for the full
+ * `timeoutMs` (default 180s). Under evict-churn (GRAPHILE_CACHE_MAX=1) every built
+ * instance stays pinned past its cache eviction, stacking ~2 builds/s × ~15MB × 180s
+ * far beyond the heap ceiling and OOMing the process. `.unref()` only removes
+ * event-loop keepalive, NOT GC retention — the timer must be cleared. clearTimeout()
+ * removes the Timeout from the timers list so the whole chain is collectable the
+ * instant the cache evicts the entry.
+ */
+/**
+ * Thrown from inside the build critical section when heap pressure reaches
+ * critical between a request's admission check and the build's actual start.
+ * The dispatcher maps it (for the requester and every coalesced waiter) to
+ * 503 SERVICE_OVERLOADED instead of a generic 500.
+ */
+export class BuildRefusedError extends Error {
+  readonly code = 'SERVICE_OVERLOADED';
+  constructor(ratio: number) {
+    super(`Schema build refused at critical heap pressure (ratio ${ratio.toFixed(2)})`);
+    this.name = 'BuildRefusedError';
+  }
+}
+
+export const raceBuildAgainstTimeout = async <T>(
+  buildPromise: Promise<T>,
+  timeoutMs: number,
+): Promise<T | null> => {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<null>((resolve) => {
+    timer = setTimeout(() => resolve(null), timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([buildPromise, timeoutPromise]);
+  } finally {
+    // Disarm the timer whether the build won, timed out, or rejected — otherwise
+    // the armed Timeout pins the built instance via the race reaction chain.
+    clearTimeout(timer);
+  }
 };
 
 export const graphile = (opts: ConstructiveOptions): RequestHandler => {
   const observabilityEnabled = isGraphqlObservabilityEnabled(opts.server?.host);
 
+  // Pause between build STARTS while heap pressure is elevated (ms; 0 disables).
+  // Bounds the allocation rate of an eviction-churn storm so GC keeps pace.
+  const buildPressureSpacingMs = (() => {
+    const n = parseInt(process.env.GRAPHILE_BUILD_PRESSURE_SPACING_MS || '', 10);
+    return Number.isFinite(n) && n >= 0 ? n : 250;
+  })();
+
   return async (req: Request, res: Response, next: NextFunction) => {
     const label = reqLabel(req);
     try {
@@ -313,21 +548,51 @@ export const graphile = (opts: ConstructiveOptions): RequestHandler => {
         log.error(`${label} Missing API info`);
         return res.status(500).send('Missing API info');
       }
-      const key = req.svc_key;
-      if (!key) {
+      const svcKey = req.svc_key;
+      if (!svcKey) {
         log.error(`${label} Missing service cache key`);
         return res.status(500).send('Missing service cache key');
       }
       const { dbname, anonRole, roleName, schema } = api;
       const schemaLabel = schema?.join(',') || 'unknown';
 
+      // =========================================================================
+      // Blueprint Pooling Decision (opt-in via GRAPHILE_BLUEPRINT_POOLING)
+      //
+      // When enabled, resolve a shared blueprint key so tenants of the same
+      // schema-shape attach to ONE instance, routed per request by the rewriting
+      // pool (the requesting tenant's schema list is set in grafast.context).
+      // Decisions are memoized per svc_key and cleared on flush. When the flag is
+      // OFF this block is skipped entirely: `key` stays exactly req.svc_key and no
+      // extra pool or queries are touched.
+      // =========================================================================
+      const pgConfig = getPgEnvOptions({ ...opts.pg, database: dbname });
+      let key = svcKey;
+      let pooling = false;
+      let pool: Pool | undefined;
+      if (isBlueprintPoolingEnabled() && api) {
+        // Blueprint keying needs the tenant pool to fingerprint the schema shape.
+        pool = getPgPool(pgConfig);
+        const decision = await resolvePoolDecision(svcKey, api, pool);
+        key = decision.key;
+        pooling = decision.pooling;
+        if (pooling) {
+          graphileCounters.poolingAttaches += 1;
+          log.info(`[pooling] svc=${svcKey} → ${key}`);
+        }
+      }
+
       // =========================================================================
       // Phase A: Cache Check (fast path)
       // =========================================================================
       const cached = graphileCache.get(key);
       if (cached) {
-        log.debug(`${label} PostGraphile cache hit key=${key} db=${dbname} schemas=${schemaLabel}`);
-        return cached.handler(req, res, next);
+        if (invokeEntryHandler(cached, req, res, next)) {
+          log.debug(`${label} PostGraphile cache hit key=${key} db=${dbname} schemas=${schemaLabel}`);
+          return;
+        }
+        // Entry is mid-disposal — fall through and rebuild.
+        log.debug(`${label} PostGraphile cache hit on disposing entry key=${key}; rebuilding`);
       }
 
       log.debug(`${label} PostGraphile cache miss key=${key} db=${dbname} schemas=${schemaLabel}`);
@@ -340,7 +605,11 @@ export const graphile = (opts: ConstructiveOptions): RequestHandler => {
         log.debug(`${label} Coalescing request for PostGraphile[${key}] - waiting for in-flight creation`);
         try {
           const instance = await inFlight;
-          return instance.handler(req, res, next);
+          if (invokeEntryHandler(instance, req, res, next)) {
+            return;
+          }
+          log.debug(`${label} Coalesced instance already disposing for PostGraphile[${key}], retrying`);
+          // Fall through to Phase C to retry creation
         } catch (error) {
           log.warn(`${label} Coalesced request failed for PostGraphile[${key}], retrying`);
           // Fall through to Phase C to retry creation
@@ -353,55 +622,180 @@ export const graphile = (opts: ConstructiveOptions): RequestHandler => {
 
       // Re-check cache after coalesced request failure (another retry may have succeeded)
       const recheckedCache = graphileCache.get(key);
-      if (recheckedCache) {
+      if (recheckedCache && invokeEntryHandler(recheckedCache, req, res, next)) {
         log.debug(`${label} PostGraphile cache hit on re-check key=${key}`);
-        return recheckedCache.handler(req, res, next);
+        return;
       }
 
       // Re-check in-flight map (another retry may have started creation)
       const retryInFlight = creating.get(key);
       if (retryInFlight) {
         log.debug(`${label} Re-coalescing request for PostGraphile[${key}]`);
-        const retryInstance = await retryInFlight;
-        return retryInstance.handler(req, res, next);
+        try {
+          const retryInstance = await retryInFlight;
+          if (invokeEntryHandler(retryInstance, req, res, next)) {
+            return;
+          }
+          log.warn(`${label} Re-coalesced instance already disposing for PostGraphile[${key}]`);
+          return res.status(503).json({
+            error: { code: 'SERVICE_ROTATING', message: 'Service is restarting, please retry' }
+          });
+        } catch (error) {
+          // A refusal surfacing on the re-coalesce await is bound by the same
+          // contract as the owner path (763) and the request-time gate (640):
+          // 503 SERVICE_OVERLOADED + Retry-After for every coalesced waiter, never
+          // a generic 500. Other rejections fall through to retry the build here,
+          // exactly as Phase B does (605).
+          if (error instanceof BuildRefusedError) {
+            log.warn(`${label} ${error.message} key=${key}`);
+            res.setHeader('Retry-After', '15');
+            return res.status(503).json({
+              error: { code: 'SERVICE_OVERLOADED', message: 'Server is at critical memory pressure; retry shortly' }
+            });
+          }
+          log.warn(`${label} Re-coalesced request failed for PostGraphile[${key}], retrying`);
+          // Fall through to build below.
+        }
+      }
+
+      // Memory governor gate: at critical heap pressure a build's transient
+      // allocation (hundreds of MB to >700MB on large catalogs) would abort the
+      // whole process. Resident instances keep serving; only NEW builds refuse.
+      const pressure = shouldRefuseBuild();
+      if (pressure.refuseBuild) {
+        res.setHeader('Retry-After', '15');
+        return res.status(503).json({
+          error: {
+            code: 'SERVICE_OVERLOADED',
+            message: 'Server is at critical memory pressure; retry shortly'
+          }
+        });
       }
 
       log.info(
         `${label} Building PostGraphile v5 handler key=${key} db=${dbname} schemas=${schemaLabel} role=${roleName} anon=${anonRole}`,
       );
 
-      const pgConfig = getPgEnvOptions({
-        ...opts.pg,
-        database: dbname,
-      });
-
       // Route through pg-cache so the pool is tracked and can be cleaned up
-      // properly, preventing leaked connections during database teardown.
-      const pool = getPgPool(pgConfig);
+      // properly, preventing leaked connections during database teardown. When the
+      // pooling decision above already resolved the pool, reuse it (pg-cache memoizes
+      // regardless); otherwise resolve it here exactly as before (flag-off path).
+      const activePool = pool ?? getPgPool(pgConfig);
 
       // Create promise and store in in-flight map BEFORE try block
-      const preset = buildPreset(pool, schema || [], anonRole, roleName, api.databaseSettings);
-      const creationPromise = observeGraphileBuild(
-        {
-          cacheKey: key,
-          serviceKey: key,
-          databaseId: api.databaseId ?? null,
-        },
-        () => createGraphileInstance({
-          preset,
-          cacheKey: key,
-          enableRealtime: api.databaseSettings?.enableRealtime,
-        }),
-        { enabled: observabilityEnabled },
-      );
+      const preset = buildPreset(activePool, schema || [], anonRole, roleName, api.databaseSettings, { pooling });
+      const creationPromise = (async (): Promise<GraphileCacheEntry> => {
+        // Serialize builds process-wide: each build transiently allocates hundreds of MB,
+        // and only same-key builds are deduped by the single-flight map above.
+        await buildSemaphore.acquire();
+        try {
+          // While queued for the slot another request may have finished this key.
+          const builtMeanwhile = graphileCache.get(key);
+          if (builtMeanwhile) {
+            return builtMeanwhile;
+          }
+          // Evict the LRU instance BEFORE building so the build peak lands on freed
+          // headroom instead of stacking on a full cache.
+          ensureCacheHeadroom(1);
+          // Evicted != freed: a draining instance's ~GB stays live until its
+          // in-flight requests finish and release completes. Stacking the build
+          // transient on undrained instances OOMed the soak — wait them out
+          // (bounded; returns immediately when heap pressure is already ok).
+          await waitForDrainSettle();
+          // The request-time pressure gate can be seconds stale by the time a
+          // queued build reaches this point: under an eviction-churn storm the
+          // dispatcher sustains tens of builds/s, each retaining ~15MB until GC
+          // catches up, so heap can cross from ok to fatal between two request
+          // admissions. Re-check at the point of allocation — and under elevated
+          // pressure pause once (semaphore held, so this spaces GLOBAL build
+          // starts) to give mark-compact a window before committing the next
+          // transient.
+          let latePressure = getMemoryPressure();
+          if (latePressure.level === 'elevated' && buildPressureSpacingMs > 0) {
+            await new Promise<void>((resolve) => setTimeout(resolve, buildPressureSpacingMs));
+            latePressure = getMemoryPressure();
+          }
+          if (latePressure.level === 'critical') {
+            const refusal = shouldRefuseBuild();
+            if (refusal.refuseBuild) {
+              throw new BuildRefusedError(refusal.ratio);
+            }
+          }
+          // A build genuinely starts here: past single-flight coalescing, past the
+          // build semaphore, and past the built-meanwhile re-check.
+          graphileCounters.builds += 1;
+          if (pooling) {
+            graphileCounters.poolingBuilds += 1;
+          }
+          return await observeGraphileBuild(
+            {
+              cacheKey: key,
+              serviceKey: key,
+              databaseId: api.databaseId ?? null,
+            },
+            () => createGraphileInstance({
+              preset,
+              cacheKey: key,
+              dbname,
+              enableRealtime: api.databaseSettings?.enableRealtime,
+            }),
+            { enabled: observabilityEnabled },
+          );
+        } finally {
+          buildSemaphore.release();
+        }
+      })();
       creating.set(key, creationPromise);
 
+      // Populate the cache and clear the in-flight slot when the BUILD settles
+      // (not when this request finishes): a request that stops waiting
+      // (build-timeout below) must leave coalescing intact for followers, and
+      // the finished build must land in the cache for their retries.
+      creationPromise
+        .then((instance) => {
+          graphileCache.set(key, instance);
+          log.info(`${label} Cached PostGraphile v5 handler key=${key} db=${dbname}`);
+        })
+        .catch(() => {
+          /* logged by the awaiting branch (or a coalesced waiter) below */
+        })
+        .finally(() => {
+          creating.delete(key);
+        });
+
       try {
-        const instance = await creationPromise;
-        graphileCache.set(key, instance);
-        log.info(`${label} Cached PostGraphile v5 handler key=${key} db=${dbname}`);
-        return instance.handler(req, res, next);
+        // Bound how long a REQUEST waits on a build (queue time + build time).
+        const timeoutMs = (() => {
+          const n = parseInt(process.env.GRAPHILE_BUILD_TIMEOUT_MS || '', 10);
+          return Number.isFinite(n) && n > 0 ? n : 180_000;
+        })();
+        const instance = await raceBuildAgainstTimeout(creationPromise, timeoutMs);
+        if (instance === null) {
+          graphileCounters.buildWaitTimeouts += 1;
+          log.warn(`${label} Request timed out after ${timeoutMs}ms waiting for PostGraphile[${key}] build`);
+          res.setHeader('Retry-After', '15');
+          return res.status(503).json({
+            error: { code: 'BUILD_TIMEOUT', message: 'Schema build in progress; retry shortly' }
+          });
+        }
+        if (invokeEntryHandler(instance, req, res, next)) {
+          return;
+        }
+        log.warn(`${label} Freshly built instance already disposing for PostGraphile[${key}]`);
+        return res.status(503).json({
+          error: { code: 'SERVICE_ROTATING', message: 'Service is restarting, please retry' }
+        });
       } catch (error) {
+        // Pressure refusal from inside the critical section: same contract as the
+        // request-time gate — 503 + Retry-After for the requester and every
+        // coalesced waiter, never a generic 500.
+        if (error instanceof BuildRefusedError) {
+          log.warn(`${label} ${error.message} key=${key}`);
+          res.setHeader('Retry-After', '15');
+          return res.status(503).json({
+            error: { code: 'SERVICE_OVERLOADED', message: 'Server is at critical memory pressure; retry shortly' }
+          });
+        }
         log.error(`${label} Failed to create PostGraphile[${key}]:`, error);
         throw new HandlerCreationError(
           `Failed to create handler for ${key}: ${error instanceof Error ? error.message : String(error)}`,
@@ -410,9 +804,6 @@ export const graphile = (opts: ConstructiveOptions): RequestHandler => {
             cause: error instanceof Error ? error.message : String(error),
           },
         );
-      } finally {
-        // Always clean up in-flight tracker
-        creating.delete(key);
       }
     } catch (e: any) {
       log.error(`${label} PostGraphile middleware error`, e);
diff --git a/graphql/server/src/middleware/introspection-filter.ts b/graphql/server/src/middleware/introspection-filter.ts
new file mode 100644
index 0000000000..9f68fea734
--- /dev/null
+++ b/graphql/server/src/middleware/introspection-filter.ts
@@ -0,0 +1,456 @@
+import { Logger } from '@pgpmjs/logger';
+
+// =============================================================================
+// Introspection filter: scope PostGraphile v5 catalog introspection to the
+// namespaces an instance actually serves.
+//
+// PostGraphile v5's introspection SQL (pg-introspection makeIntrospectionQuery)
+// is UNSCOPED: it ingests the entire pg_class catalog (tens of thousands of rows
+// on a shared multi-tenant database) into every built instance, and the parsed
+// result's internal cross-references pin ~1.4GB of heap per instance regardless
+// of how few schemas that instance serves. This module intercepts the single,
+// static, parameter-less introspection statement as it flows through the pg pool
+// wrapper we already own and rewrites its four namespace gates so only the
+// served schemas (plus their transitive cross-schema references, plus public and
+// pg_catalog) are ingested.
+//
+// It is intentionally FAIL-OPEN: any shape it does not recognize (gate count !=
+// 4, a non-introspection query, an empty served-schema set, the feature flag
+// off) falls straight back to today's stock behavior. The one non-open path is a
+// throwing discovery query — that fails the instance build, which the caller
+// already retries on later requests, and is preferable to serving an instance
+// built on an under-scoped (data-losing) catalog.
+//
+// The rewrite touches SQL STRING LITERALS only (single-quoted schema names in an
+// `= any(array[...])`); it never emits double-quoted identifiers, so the sibling
+// rewrite-pool's identifier lexer neither sees nor rewrites anything here.
+// =============================================================================
+
+const log = new Logger('graphile:introspection-filter');
+
+// The exact namespace-gate substring emitted by pg-introspection@1.0.1's
+// makeIntrospectionQuery(). It appears EXACTLY 4 times (classes.relnamespace,
+// constraints.connamespace, procs.pronamespace, types.typnamespace). The types
+// gate is followed by `or (typnamespace = 'pg_catalog'::regnamespace)` which we
+// leave intact so pg_catalog types survive. NOTE the single backslash before the
+// underscore: that is the runtime string (the .js source shows a doubled
+// backslash only because it sits in a template literal). Verified by test
+// against the installed package rather than hand-transcription.
+const GATE_SUBSTRING =
+  "in (select namespaces._id from namespaces where nspname <> 'information_schema' and nspname not like 'pg\\_%')";
+
+// Cheap structural signature of the introspection statement. Ordinary
+// GraphQL-generated SQL can never satisfy all three of these simultaneously.
+const INTROSPECTION_PREFIX = 'with\n  database as (';
+const INTROSPECTION_MARKER = ')::text as introspection';
+const INTROSPECTION_VERSION_TOKEN = 'introspection_version';
+
+// -----------------------------------------------------------------------------
+// Env flag
+// -----------------------------------------------------------------------------
+
+/**
+ * Whether the introspection filter is enabled via GRAPHILE_INTROSPECTION_FILTER.
+ * Accepts '1' or 'true'; anything else (incl. unset) means disabled. Mirrors the
+ * GRAPHILE_BLUEPRINT_POOLING read in blueprint.ts.
+ */
+export const isIntrospectionFilterEnabled = (): boolean => {
+  const value = process.env.GRAPHILE_INTROSPECTION_FILTER;
+  return value === '1' || value === 'true';
+};
+
+// -----------------------------------------------------------------------------
+// Counters
+// -----------------------------------------------------------------------------
+
+export interface IntrospectionFilterCounters {
+  /** Closure-discovery passes actually run (one per intercepted introspection). */
+  discoveries: number;
+  /** Introspection queries whose text was swapped for a filtered one. */
+  swaps: number;
+  /** Callback-form or otherwise unfilterable introspection queries passed through. */
+  failures: number;
+  /** Times buildFilteredIntrospectionQuery returned null (gate count != 4). */
+  gateMismatches: number;
+  /** Closure loops that hit the 5-round cap before converging. */
+  closureTruncations: number;
+  /** Total namespaces retained by the most recent successful filter build. */
+  keepNamespaceCount: number;
+}
+
+/** Build a zeroed counters object (companion to the interceptor opts). */
+export const createIntrospectionFilterCounters = (): IntrospectionFilterCounters => ({
+  discoveries: 0,
+  swaps: 0,
+  failures: 0,
+  gateMismatches: 0,
+  closureTruncations: 0,
+  keepNamespaceCount: 0
+});
+
+// Process-wide sink: the default counters when an interceptor/pool is created
+// without its own, so getIntrospectionFilterCounters() (read by the metrics
+// sampler) reflects real activity aggregated across every filtered instance.
+const moduleCounters = createIntrospectionFilterCounters();
+
+/** Snapshot the process-wide introspection-filter counters (metrics sampler entry point). Returns a copy so callers cannot mutate live state. */
+export const getIntrospectionFilterCounters = (): IntrospectionFilterCounters => ({
+  ...moduleCounters
+});
+
+/**
+ * Record a callback-form introspection query that had to be passed through
+ * unfiltered (callback semantics are never rewritten). Bumps the module sink so
+ * the rewrite-pool integration can report it without owning its own counters.
+ */
+export const noteIntrospectionCallbackPassthrough = (): void => {
+  moduleCounters.failures += 1;
+};
+
+// -----------------------------------------------------------------------------
+// Query detection
+// -----------------------------------------------------------------------------
+
+/**
+ * Cheap signature check for the pg-introspection statement. Robust against
+ * user/GraphQL-generated SQL: requires the length floor, the real CTE prefix,
+ * the trailing `)::text as introspection` marker AND the introspection_version
+ * token together.
+ */
+export const isIntrospectionQuery = (text: string): boolean => {
+  if (typeof text !== 'string' || text.length <= 5000) return false;
+  return (
+    text.startsWith(INTROSPECTION_PREFIX) &&
+    text.includes(INTROSPECTION_MARKER) &&
+    text.includes(INTROSPECTION_VERSION_TOKEN)
+  );
+};
+
+// -----------------------------------------------------------------------------
+// Filtered-query builder
+// -----------------------------------------------------------------------------
+
+/** Escape a value as a SQL string literal body (single quotes doubled). */
+const sqlLiteral = (value: string): string => "'" + value.replace(/'/g, "''") + "'";
+
+const isRejectedNamespace = (name: string): boolean =>
+  name.length === 0 ||
+  name.includes('\u0000') ||
+  name === 'information_schema' ||
+  name.startsWith('pg_');
+
+/**
+ * Rewrite the four namespace gates of the stock introspection text so only
+ * `keepNamespaces` (sorted, deduped, escaped) are ingested. Returns null when
+ * the gate substring does not appear exactly 4 times (the caller then falls back
+ * to the stock text). Names starting 'pg_' / equal to 'information_schema' /
+ * containing NUL are defensively dropped from the injected array; the intact
+ * `or (typnamespace = 'pg_catalog'::regnamespace)` branch keeps pg_catalog
+ * types.
+ */
+export const buildFilteredIntrospectionQuery = (
+  stockText: string,
+  keepNamespaces: string[]
+): string | null => {
+  const occurrences = stockText.split(GATE_SUBSTRING).length - 1;
+  if (occurrences !== 4) return null;
+
+  const cleaned = Array.from(new Set(keepNamespaces.filter((n) => !isRejectedNamespace(n)))).sort();
+  const arrayLiteral =
+    cleaned.length === 0
+      ? "in (select namespaces._id from namespaces where false)"
+      : 'in (select namespaces._id from namespaces where nspname = any (array[' +
+        cleaned.map(sqlLiteral).join(', ') +
+        ']::text[]))';
+
+  return stockText.split(GATE_SUBSTRING).join(arrayLiteral);
+};
+
+// -----------------------------------------------------------------------------
+// Namespace-closure discovery
+// -----------------------------------------------------------------------------
+
+// One round of closure discovery. Given the already-kept namespaces ($1), return
+// NEW namespaces referenced by objects living in kept namespaces, via three arms:
+//   1. FK targets:      pg_constraint(contype='f') in kept classes -> confrelid ns
+//   2. attribute types: live attributes of kept classes -> atttypid ns, plus that
+//                       type's typbasetype and typelem namespaces when nonzero
+//   3. proc types:      pg_proc in kept namespaces -> prorettype ns + arg-type ns
+// Every arm schema-qualifies pg_catalog.* (no search_path) and excludes
+// information_schema, pg_* namespaces, and names already in the kept set.
+const CLOSURE_ROUND_SQL = `
+with kept as (
+  select n.oid
+  from pg_catalog.pg_namespace n
+  where n.nspname = any ($1::text[])
+),
+kept_classes as (
+  select c.oid, c.relnamespace
+  from pg_catalog.pg_class c
+  where c.relnamespace in (select oid from kept)
+),
+referenced as (
+  -- arm 1: foreign-key target namespaces
+  select tc.relnamespace as nsoid
+  from pg_catalog.pg_constraint con
+  join kept_classes kc on kc.oid = con.conrelid
+  join pg_catalog.pg_class tc on tc.oid = con.confrelid
+  where con.contype = 'f'
+
+  union
+
+  -- arm 2: attribute type namespaces (+ base/element type namespaces)
+  select t.typnamespace as nsoid
+  from pg_catalog.pg_attribute a
+  join kept_classes kc on kc.oid = a.attrelid
+  join pg_catalog.pg_type t on t.oid = a.atttypid
+  where a.attnum > 0 and not a.attisdropped
+
+  union
+  select bt.typnamespace as nsoid
+  from pg_catalog.pg_attribute a
+  join kept_classes kc on kc.oid = a.attrelid
+  join pg_catalog.pg_type t on t.oid = a.atttypid
+  join pg_catalog.pg_type bt on bt.oid = t.typbasetype
+  where a.attnum > 0 and not a.attisdropped and t.typbasetype <> 0
+
+  union
+  select et.typnamespace as nsoid
+  from pg_catalog.pg_attribute a
+  join kept_classes kc on kc.oid = a.attrelid
+  join pg_catalog.pg_type t on t.oid = a.atttypid
+  join pg_catalog.pg_type et on et.oid = t.typelem
+  where a.attnum > 0 and not a.attisdropped and t.typelem <> 0
+
+  union
+
+  -- arm 3: proc return-type and argument-type namespaces
+  select rt.typnamespace as nsoid
+  from pg_catalog.pg_proc p
+  join pg_catalog.pg_type rt on rt.oid = p.prorettype
+  where p.pronamespace in (select oid from kept)
+
+  union
+  select at.typnamespace as nsoid
+  from pg_catalog.pg_proc p
+  cross join lateral unnest(p.proargtypes) as pat(argoid)
+  join pg_catalog.pg_type at on at.oid = pat.argoid
+  where p.pronamespace in (select oid from kept)
+)
+select distinct n.nspname
+from referenced r
+join pg_catalog.pg_namespace n on n.oid = r.nsoid
+where n.nspname <> 'information_schema'
+  and n.nspname not like 'pg\\_%'
+  and n.nspname <> all ($1::text[])
+`;
+
+const MAX_CLOSURE_ROUNDS = 5;
+
+/** Minimal shape of the checked-out client the discovery needs. */
+interface RawClientLike {
+  query(sql: string, values?: any[]): Promise<{ rows: any[] }>;
+}
+
+/**
+ * Iterate CLOSURE_ROUND_SQL in JS until a round adds nothing or the round cap is
+ * hit. Starting set = servedSchemas ∪ {'public'}. Runs sequential queries on the
+ * provided (exclusively checked-out) client. Returns the accumulated keep set and
+ * whether the cap truncated the walk.
+ */
+const discoverKeepNamespaces = async (
+  client: RawClientLike,
+  servedSchemas: string[]
+): Promise<{ keep: string[]; truncated: boolean }> => {
+  const keep = new Set<string>(['public']);
+  for (const s of servedSchemas) {
+    if (typeof s === 'string' && s.length > 0) keep.add(s);
+  }
+
+  let truncated = true;
+  for (let round = 0; round < MAX_CLOSURE_ROUNDS; round++) {
+    const result = await client.query(CLOSURE_ROUND_SQL, [Array.from(keep)]);
+    const added: string[] = [];
+    for (const row of result.rows) {
+      const name = row.nspname;
+      if (typeof name === 'string' && !keep.has(name)) {
+        keep.add(name);
+        added.push(name);
+      }
+    }
+    if (added.length === 0) {
+      truncated = false;
+      break;
+    }
+  }
+
+  return { keep: Array.from(keep), truncated };
+};
+
+// -----------------------------------------------------------------------------
+// Interceptor
+// -----------------------------------------------------------------------------
+
+export interface IntrospectionInterceptorOptions {
+  /** Physical schema names this instance serves (the discovery seed, sans public). */
+  servedSchemas: string[];
+  /** Optional shared counters; the module sink is used when omitted. */
+  counters?: IntrospectionFilterCounters;
+}
+
+/**
+ * The interceptor callback: given the stock introspection text and the raw
+ * checked-out client, resolves to the text to actually execute. Returns null
+ * (synchronously) when the filter must not apply — filter disabled, no served
+ * schemas, or the text is not the introspection query — so the caller runs the
+ * original query unchanged.
+ *
+ * On the filtering path it memoizes: the closure discovery + filtered text are
+ * computed once per interceptor (i.e. once per instance build) and reused for any
+ * subsequent introspection on the same interceptor. A gate mismatch records the
+ * reason, warns once, and returns the STOCK text (graceful fallback). A throwing
+ * discovery query rejects (the instance build fails and is retried later).
+ */
+export type IntrospectionInterceptor = (
+  text: string,
+  rawClient: RawClientLike
+) => Promise<string> | null;
+
+export const createIntrospectionInterceptor = (
+  opts: IntrospectionInterceptorOptions
+): IntrospectionInterceptor => {
+  const counters = opts.counters ?? moduleCounters;
+  const servedSchemas = Array.isArray(opts.servedSchemas) ? opts.servedSchemas : [];
+
+  let memo: Promise<string> | null = null;
+  let warnedGateMismatch = false;
+
+  return (text: string, rawClient: RawClientLike): Promise<string> | null => {
+    if (!isIntrospectionFilterEnabled()) return null;
+    if (servedSchemas.length === 0) return null;
+    if (!isIntrospectionQuery(text)) return null;
+
+    if (memo) return memo;
+
+    memo = (async (): Promise<string> => {
+      counters.discoveries += 1;
+      const { keep, truncated } = await discoverKeepNamespaces(rawClient, servedSchemas);
+      if (truncated) counters.closureTruncations += 1;
+
+      const filtered = buildFilteredIntrospectionQuery(text, keep);
+      if (filtered === null) {
+        counters.gateMismatches += 1;
+        if (!warnedGateMismatch) {
+          warnedGateMismatch = true;
+          log.warn(
+            'introspection gate substring not found exactly 4 times; falling back to unfiltered introspection'
+          );
+        }
+        return text;
+      }
+
+      counters.swaps += 1;
+      counters.keepNamespaceCount = keep.length;
+      return filtered;
+    })();
+
+    // A rejected discovery must not poison later attempts (the build is retried).
+    memo.catch(() => {
+      memo = null;
+    });
+
+    return memo;
+  };
+};
+
+// -----------------------------------------------------------------------------
+// Dedicated-instance pool wrapper
+// -----------------------------------------------------------------------------
+
+export interface IntrospectionFilterPoolOptions {
+  /** Physical schema names this dedicated instance serves. */
+  servedSchemas: string[];
+  /** Optional shared counters; the module sink is used when omitted. */
+  counters?: IntrospectionFilterCounters;
+}
+
+/**
+ * Thin Proxy over a raw pg Pool for DEDICATED (non-pooled) instances: intercepts
+ * a checked-out client's introspection query and swaps it for the filtered text.
+ * Everything else passes through untouched. No settings parsing, identifier
+ * rewriting, or prepared-name logic (unlike rewrite-pool). The per-checkout
+ * interceptor closure is a per-connection memo; release restores nothing.
+ */
+export const createIntrospectionFilterPool = (pool: any, opts: IntrospectionFilterPoolOptions): any => {
+  const counters = opts.counters ?? moduleCounters;
+  const servedSchemas = opts.servedSchemas;
+
+  const wrapClient = (client: any): any => {
+    const interceptor = createIntrospectionInterceptor({ servedSchemas, counters });
+
+    const interceptQuery = (rawQuery: any, thisArg: any, args: any[]): any => {
+      const first = args[0];
+
+      // Promise-form config object with a text field is the only introspection
+      // shape (the @dataplan/pg adaptor runs `client.query({ text })`). A callback
+      // last-arg means callback semantics: never filter, count and pass through.
+      let text: string | undefined;
+      if (typeof first === 'string') text = first;
+      else if (first && typeof first === 'object' && typeof first.text === 'string') text = first.text;
+
+      const hasCallback = typeof args[args.length - 1] === 'function';
+
+      if (text !== undefined && isIntrospectionQuery(text)) {
+        if (hasCallback) {
+          counters.failures += 1;
+          return rawQuery.apply(thisArg, args);
+        }
+        const swapPromise = interceptor(text, { query: (sql, values) => thisArg.query(sql, values) });
+        if (swapPromise === null) {
+          return rawQuery.apply(thisArg, args);
+        }
+        return Promise.resolve(swapPromise).then((swapped) => {
+          if (swapped === text) return rawQuery.apply(thisArg, args);
+          if (typeof first === 'string') {
+            return rawQuery.apply(thisArg, [swapped, ...args.slice(1)]);
+          }
+          return rawQuery.apply(thisArg, [{ ...first, text: swapped }, ...args.slice(1)]);
+        });
+      }
+
+      return rawQuery.apply(thisArg, args);
+    };
+
+    return new Proxy(client, {
+      get(target, prop, receiver) {
+        if (prop === 'query') {
+          return (...args: any[]) => interceptQuery(target.query, target, args);
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === 'function' ? value.bind(target) : value;
+      }
+    });
+  };
+
+  return new Proxy(pool, {
+    get(target, prop, receiver) {
+      if (prop === 'connect') {
+        return (...args: any[]) => {
+          if (typeof args[0] === 'function') {
+            const cb = args[0];
+            return target.connect((err: any, client: any, done: any) => {
+              if (err) {
+                cb(err, client, done);
+                return;
+              }
+              cb(err, wrapClient(client), done);
+            });
+          }
+          return Promise.resolve(target.connect(...args)).then((client: any) => wrapClient(client));
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === 'function' ? value.bind(target) : value;
+    }
+  });
+};
diff --git a/graphql/server/src/middleware/pooling-decision.ts b/graphql/server/src/middleware/pooling-decision.ts
new file mode 100644
index 0000000000..a4656addef
--- /dev/null
+++ b/graphql/server/src/middleware/pooling-decision.ts
@@ -0,0 +1,148 @@
+import { Logger } from '@pgpmjs/logger';
+import type { Pool } from 'pg';
+
+import type { ApiStructure } from '../types';
+import {
+  computeBlueprintKey,
+  fetchSchemaRelations,
+  fingerprintFromRelations,
+  stripSchemaHashPrefix
+} from './blueprint';
+
+// =============================================================================
+// Blueprint Pooling: per-svc decision + decision cache
+//
+// Decides whether a service (svc_key) may attach to a SHARED PostGraphile
+// instance (blueprint pooling, tenant-routed by the rewriting pool — see
+// ./rewrite-pool) or must keep a per-tenant instance.
+// Kept in its own module — free of the heavy graphile.ts import chain — so the
+// decision logic is unit-testable without loading PostGraphile.
+// =============================================================================
+
+const log = new Logger('graphile:pooling');
+
+export interface PoolDecision {
+  /** Effective graphileCache key: a `bp:` blueprint key when pooling, else the svc_key. */
+  key: string;
+  /** Whether this svc attaches to a shared (blueprint-pooled) instance. */
+  pooling: boolean;
+  /**
+   * True when the fallback came from a thrown catalog probe (a possibly
+   * transient DB error) rather than a structural opt-out. Transient decisions
+   * are NOT memoized, so the next request re-probes instead of permanently
+   * pinning the svc to a per-tenant instance until the next flush.
+   */
+  transient?: boolean;
+  /**
+   * The tenant database this decision belongs to — lets flushService invalidate
+   * ONLY the affected database's decisions/blueprint instead of a fleet-wide
+   * flush on every schema:update.
+   */
+  databaseId?: string;
+}
+
+/**
+ * Memoized pooling decision per svc_key. Computing a decision runs one catalog
+ * probe (the shape fingerprint), so the result is cached and invalidated on
+ * flush (see clearPoolDecisions / flushService).
+ */
+const poolDecisions = new Map<string, PoolDecision>();
+
+/**
+ * Clear all cached pooling decisions (explicit /flush admin route).
+ */
+export function clearPoolDecisions(): void {
+  poolDecisions.clear();
+}
+
+/**
+ * Invalidate ONLY the decisions belonging to one tenant database and return the
+ * `bp:` keys it was attached to (so flushService can rebuild exactly the
+ * affected blueprint). A schema change in tenant X:
+ *   - X's decisions must recompute (its fingerprint may have changed), and
+ *   - the blueprint instance X was pooled into must rebuild (its shared schema
+ *     was derived from a catalog that included X's old shape),
+ * while every OTHER blueprint keeps serving untouched. A brand-new tenant has
+ * no memoized decisions => provisioning events are a no-op here (new tenants
+ * probe on first request; instances are shape-generic and need no rebuild to
+ * accept another same-shape tenant).
+ */
+export function clearPoolDecisionsForDatabase(databaseId: string): string[] {
+  const bpKeys = new Set<string>();
+  for (const [svcKey, decision] of poolDecisions) {
+    if (decision.databaseId === databaseId) {
+      if (decision.pooling && decision.key.startsWith('bp:')) {
+        bpKeys.add(decision.key);
+      }
+      poolDecisions.delete(svcKey);
+    }
+  }
+  return [...bpKeys];
+}
+
+/**
+ * Compute (WITHOUT caching) the blueprint-pooling decision for a service.
+ *
+ * Returns `{ pooling: false, key: svcKey }` — a per-tenant instance keyed by the
+ * normal svc_key — when the API opts out of pooling: realtime is enabled, there
+ * are no schemas, or the catalog probe throws. Otherwise returns
+ * `{ pooling: true, key: 'bp:...' }` so same-shape tenants share one instance.
+ *
+ * Exported for unit testing; the dispatcher uses the cached resolvePoolDecision.
+ */
+export const computePoolDecision = async (
+  svcKey: string,
+  api: ApiStructure,
+  pool: Pool
+): Promise<PoolDecision> => {
+  // Realtime instances hold a LISTEN/NOTIFY connection + RealtimeManager per
+  // instance and can't be safely shared across tenants — never pool them.
+  if (api.databaseSettings?.enableRealtime === true) {
+    return { key: svcKey, pooling: false };
+  }
+  if (!api.schema || api.schema.length === 0) {
+    return { key: svcKey, pooling: false };
+  }
+
+  try {
+    // One catalog scan feeds the fingerprint.
+    const relations = await fetchSchemaRelations(pool, api.schema);
+
+    const key = computeBlueprintKey({
+      logicalSchemas: api.logicalSchemas ?? api.schema.map(stripSchemaHashPrefix),
+      shapeFingerprint: fingerprintFromRelations(relations),
+      flags: api.databaseSettings as Record<string, any> | undefined,
+      apiName: (api as { apiName?: string | null }).apiName ?? null,
+      mode: 'public',
+      dbname: api.dbname
+    });
+    return { key, pooling: true };
+  } catch (err) {
+    log.warn(
+      `svc=${svcKey} not poolable — shape probe failed: ${err instanceof Error ? err.message : String(err)}; using per-tenant instance (not memoized)`
+    );
+    return { key: svcKey, pooling: false, transient: true };
+  }
+};
+
+/**
+ * Resolve the pooling decision for a service, memoized per svc_key. Exported for
+ * unit testing of the memoization/invalidation behaviour.
+ */
+export const resolvePoolDecision = async (
+  svcKey: string,
+  api: ApiStructure,
+  pool: Pool
+): Promise<PoolDecision> => {
+  const cached = poolDecisions.get(svcKey);
+  if (cached) return cached;
+  const decision = await computePoolDecision(svcKey, api, pool);
+  if (!decision.transient) {
+    // Stamp the owning database once, at the single memoization point, so
+    // flushService can invalidate per-database instead of fleet-wide.
+    const memoized: PoolDecision = { ...decision, databaseId: (api as any).databaseId ?? undefined };
+    poolDecisions.set(svcKey, memoized);
+    return memoized;
+  }
+  return decision;
+};
diff --git a/graphql/server/src/middleware/rewrite-pool.ts b/graphql/server/src/middleware/rewrite-pool.ts
new file mode 100644
index 0000000000..528afd9cbe
--- /dev/null
+++ b/graphql/server/src/middleware/rewrite-pool.ts
@@ -0,0 +1,696 @@
+import { createHash } from 'node:crypto';
+
+import {
+  createIntrospectionInterceptor,
+  type IntrospectionInterceptor,
+  isIntrospectionQuery,
+  noteIntrospectionCallbackPassthrough
+} from './introspection-filter';
+
+// =============================================================================
+// Rewriting pool: per-request tenant schema rewriting for a pooled instance
+//
+// One PostGraphile instance is pooled across many tenants whose PostgreSQL
+// schemas are shape-identical but differently prefixed (e.g. canonical
+// `myapp-a1b2c3d4-app-public` vs tenant `other-9f8e7d6c-app-public`). The
+// pooled instance emits fully-qualified SQL naming the CANONICAL tenant's
+// schemas. This module wraps the `pg` Pool handed to the PostGraphile adaptor
+// and, per request, rewrites the canonical schema identifiers to the requesting
+// tenant's — plus namespaces prepared-statement names per tenant so one tenant's
+// prepared plan never serves another.
+//
+// Tenant identity arrives inside the adaptor's pgSettings query via a custom GUC
+// (POOL_SCHEMAS_GUC). Until a checkout has seen that GUC it has NO mapping; any
+// query that would otherwise ship canonical SQL FAILS CLOSED rather than read
+// the wrong tenant's data.
+//
+// The SQL rewriting is a single-pass lexer that rewrites ONLY double-quoted
+// identifier tokens — never string literals, dollar-quoted bodies, comments or
+// E-strings — so output is byte-identical to input except for replaced idents.
+// =============================================================================
+
+export const POOL_SCHEMAS_GUC = 'constructive.pool_schemas';
+
+export interface RewriteCounters {
+  settingsParses: number;
+  rewrittenQueries: number;
+  memoHits: number;
+  failClosed: number;
+  nameRewrites: number;
+}
+
+export interface RewritingPoolOptions {
+  /** Physical schema names the pooled instance was built against. */
+  canonicalSchemas: string[];
+  /** Maps a physical schema name to its logical (prefix-stripped) name. Injected. */
+  logicalName: (physical: string) => string;
+  /** LRU cap for both the needs-rewrite and rewrite-result memos. Default 2000. */
+  maxMemoEntries?: number;
+  /**
+   * Per-connection cap on the prepared-statement names we issue. Defaults to the
+   * adaptor's own DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE parse (unset -> 100).
+   */
+  maxPreparedNames?: number;
+  /** Optional shared counters; a fresh set is created when omitted. */
+  counters?: RewriteCounters;
+  /**
+   * When set, the pooled instance's catalog introspection query is scoped to the
+   * given served schemas (plus their transitive cross-schema references, public
+   * and pg_catalog) before it runs — see ./introspection-filter. `false`/omitted
+   * leaves introspection unfiltered (today's behavior).
+   */
+  introspectionFilter?: { servedSchemas: string[] } | false;
+}
+
+/** Build a zeroed counters object (companion to RewritingPoolOptions.counters). */
+export function createRewriteCounters(): RewriteCounters {
+  return {
+    settingsParses: 0,
+    rewrittenQueries: 0,
+    memoHits: 0,
+    failClosed: 0,
+    nameRewrites: 0
+  };
+}
+
+// Process-wide counters: the default sink when a pool is created without its own
+// counters, so getRewritePoolCounters() (read by the metrics sampler) reflects
+// real pooled activity aggregated across every pooled instance.
+const moduleCounters = createRewriteCounters();
+
+/** Snapshot the process-wide rewrite-pool counters (metrics sampler entry point). Returns a copy so callers cannot mutate live state. */
+export function getRewritePoolCounters(): RewriteCounters {
+  return { ...moduleCounters };
+}
+
+// -----------------------------------------------------------------------------
+// SQL lexer
+// -----------------------------------------------------------------------------
+
+const isIdentChar = (ch: string | undefined): boolean => {
+  if (ch === undefined) return false;
+  return (
+    (ch >= 'a' && ch <= 'z') ||
+    (ch >= 'A' && ch <= 'Z') ||
+    (ch >= '0' && ch <= '9') ||
+    ch === '_' ||
+    ch === '$'
+  );
+};
+
+const isTagStartChar = (ch: string | undefined): boolean => {
+  if (ch === undefined) return false;
+  return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
+};
+
+const isTagChar = (ch: string | undefined): boolean =>
+  isTagStartChar(ch) || (ch !== undefined && ch >= '0' && ch <= '9');
+
+/**
+ * If `text[i]` opens a dollar-quote tag (`$$` or `$tag$` where the tag follows
+ * unquoted-identifier rules), return the full opening tag (e.g. `$$`, `$body$`);
+ * otherwise null. Positional params like `$1` return null (digit-led tag).
+ */
+const matchDollarTag = (text: string, i: number): string | null => {
+  // text[i] === '$'
+  const next = text[i + 1];
+  if (next === '$') return '$$';
+  if (!isTagStartChar(next)) return null;
+  let j = i + 2;
+  while (j < text.length && isTagChar(text[j])) j++;
+  if (text[j] === '$') return text.slice(i, j + 1);
+  return null;
+};
+
+interface IdentifierToken {
+  /** Index of the opening `"`. */
+  start: number;
+  /** Index just past the closing `"`. */
+  end: number;
+  /** Unescaped identifier value (`""` collapsed to `"`). */
+  value: string;
+}
+
+/**
+ * Single left-to-right scan collecting every double-quoted identifier token,
+ * skipping over string literals, E-strings, dollar-quoted bodies, and line /
+ * (nested) block comments. This is the ONLY place identifier boundaries are
+ * decided; both public helpers below reuse it.
+ */
+const scanIdentifierTokens = (text: string): IdentifierToken[] => {
+  const tokens: IdentifierToken[] = [];
+  const n = text.length;
+  let i = 0;
+
+  while (i < n) {
+    const ch = text[i];
+
+    // Line comment -- ... to end of line
+    if (ch === '-' && text[i + 1] === '-') {
+      i += 2;
+      while (i < n && text[i] !== '\n') i++;
+      continue;
+    }
+
+    // Block comment /* ... */ (nested)
+    if (ch === '/' && text[i + 1] === '*') {
+      i += 2;
+      let depth = 1;
+      while (i < n && depth > 0) {
+        if (text[i] === '/' && text[i + 1] === '*') {
+          depth++;
+          i += 2;
+        } else if (text[i] === '*' && text[i + 1] === '/') {
+          depth--;
+          i += 2;
+        } else {
+          i++;
+        }
+      }
+      continue;
+    }
+
+    // Double-quoted identifier — the only token we ever rewrite
+    if (ch === '"') {
+      const start = i;
+      i++;
+      let value = '';
+      while (i < n) {
+        if (text[i] === '"') {
+          if (text[i + 1] === '"') {
+            value += '"';
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        value += text[i];
+        i++;
+      }
+      tokens.push({ start, end: i, value });
+      continue;
+    }
+
+    // Dollar-quoted string $tag$ ... $tag$
+    if (ch === '$') {
+      const tag = matchDollarTag(text, i);
+      if (tag !== null) {
+        i += tag.length;
+        const close = text.indexOf(tag, i);
+        i = close === -1 ? n : close + tag.length;
+        continue;
+      }
+    }
+
+    // E-string: a standalone e/E immediately followed by a quote. Both \\-style
+    // backslash escapes AND '' count; a backslash escapes the next char.
+    if ((ch === 'e' || ch === 'E') && text[i + 1] === "'" && !isIdentChar(text[i - 1])) {
+      i += 2;
+      while (i < n) {
+        const c = text[i];
+        if (c === '\\') {
+          i += 2;
+          continue;
+        }
+        if (c === "'") {
+          if (text[i + 1] === "'") {
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+
+    // Regular single-quoted string literal ('' is an escaped quote)
+    if (ch === "'") {
+      i++;
+      while (i < n) {
+        if (text[i] === "'") {
+          if (text[i + 1] === "'") {
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+
+    i++;
+  }
+
+  return tokens;
+};
+
+/**
+ * Rewrite ONLY double-quoted identifier tokens whose unescaped value is a key of
+ * `map`. String literals, dollar-quoted bodies, comments, E-strings and
+ * unquoted words are never touched. Output is byte-identical to input except for
+ * replaced tokens (a replacement is re-quoted with embedded `"` doubled).
+ */
+export function rewriteQuotedIdentifiers(text: string, map: Map<string, string>): string {
+  const tokens = scanIdentifierTokens(text);
+  if (tokens.length === 0) return text;
+
+  let out = '';
+  let last = 0;
+  for (const tok of tokens) {
+    const replacement = map.get(tok.value);
+    // Non-matches keep their original bytes: they stay inside the next verbatim
+    // slice because `last` only advances past tokens we actually replace.
+    if (replacement === undefined) continue;
+    out += text.slice(last, tok.start);
+    out += '"' + replacement.replace(/"/g, '""') + '"';
+    last = tok.end;
+  }
+  if (last === 0) return text;
+  out += text.slice(last);
+  return out;
+}
+
+/**
+ * True iff `text` contains any of `names` as a complete double-quoted identifier
+ * token (same lexer as rewriteQuotedIdentifiers — matches on the unescaped
+ * value, so an identifier merely prefixing a longer one does not count).
+ */
+export function containsQuotedIdentifier(text: string, names: Set<string>): boolean {
+  const tokens = scanIdentifierTokens(text);
+  for (const tok of tokens) {
+    if (names.has(tok.value)) return true;
+  }
+  return false;
+}
+
+// -----------------------------------------------------------------------------
+// Small insertion-order LRU (bounded memo). A stored `false`/'' is a real value,
+// so callers distinguish a miss via `has()` rather than an undefined return.
+// -----------------------------------------------------------------------------
+
+class LruCache<V> {
+  private readonly map = new Map<string, V>();
+  constructor(private readonly max: number) {}
+
+  has(key: string): boolean {
+    return this.map.has(key);
+  }
+
+  get(key: string): V | undefined {
+    if (!this.map.has(key)) return undefined;
+    const value = this.map.get(key);
+    // Touch: move to most-recently-used position.
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+
+  set(key: string, value: V): void {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      this.map.delete(oldest);
+    }
+  }
+}
+
+// -----------------------------------------------------------------------------
+// Pool / client wrapper
+// -----------------------------------------------------------------------------
+
+interface CheckoutState {
+  /** Canonical -> tenant physical schema map; null until a settings query lands. */
+  tenantMap: Map<string, string> | null;
+  /** Per-tenant namespace tag; null in identity mode (canonical querying itself). */
+  tenantTag: string | null;
+  /** Set when the tenant schema set can't satisfy the canonical shape (fail closed). */
+  invalidReason: string | null;
+  /** Per-checkout introspection interceptor (memoizes discovery); null when the filter is off. */
+  introspectionInterceptor: IntrospectionInterceptor | null;
+}
+
+const freshState = (): CheckoutState => ({
+  tenantMap: null,
+  tenantTag: null,
+  invalidReason: null,
+  introspectionInterceptor: null
+});
+
+const sha256hex = (input: string): string => createHash('sha256').update(input).digest('hex');
+
+/** Deterministic per-tenant prepared-statement name: same tenant+name -> same result. */
+const hashName = (tenantTag: string, name: string): string =>
+  'bp_' + sha256hex(tenantTag + ':' + name).slice(0, 24);
+
+// The adaptor's fixed pgSettings statement (@dataplan/pg adaptors/pg.js: the
+// `select set_config(el->>0, el->>1, true) from json_array_elements($1::json) el`
+// it issues with the JSON-serialized pgSettings as $1). Settings detection MUST
+// key on THIS TEXT — never on parameter contents alone: a data query whose
+// user-controlled bind value merely contains the GUC substring must never be
+// classified as the settings query, or it would be forwarded UNREWRITTEN (canonical
+// SQL on the tenant connection) and its value could remap or null the checkout's
+// tenant state for sibling queries. This literal byte-matches SQL emitted upstream.
+// Exported ONLY for the pinning test that asserts it against the installed
+// @dataplan/pg source — a dependency bump that changes the statement must fail
+// loudly at test time, not silently fail-closed at runtime.
+export const SETTINGS_QUERY_TEXT =
+  'select set_config(el->>0, el->>1, true) from json_array_elements($1::json) el';
+
+const isSettingsText = (text: string): boolean => text === SETTINGS_QUERY_TEXT;
+
+const isSettingsValues = (values: any): boolean =>
+  Array.isArray(values) &&
+  values.length > 0 &&
+  typeof values[0] === 'string' &&
+  values[0].includes(POOL_SCHEMAS_GUC);
+
+// Per-connection prepared-statement state lives on the RAW client under this
+// module-private Symbol: prepared statements are physical-connection scoped and
+// must survive checkout/release (unlike per-checkout tenant state).
+const BP_PREPARED = Symbol('constructive.rewrite-pool.prepared');
+
+/**
+ * Replicate @dataplan/pg's DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE parse:
+ * unset / empty / non-numeric -> 100; an explicit 0 -> 0 (upstream then disables
+ * prepared statements entirely, so our LRU is never exercised).
+ */
+const parsePreparedStatementCacheSize = (raw: string | undefined): number => {
+  const fromEnv = raw ? parseInt(raw, 10) : null;
+  return !!fromEnv || fromEnv === 0 ? fromEnv : 100;
+};
+
+export function createRewritingPool(pool: any, opts: RewritingPoolOptions): any {
+  const counters = opts.counters ?? moduleCounters;
+  const maxMemoEntries = opts.maxMemoEntries ?? 2000;
+  const maxPreparedNames =
+    opts.maxPreparedNames ??
+    parsePreparedStatementCacheSize(process.env.DATAPLAN_PG_PREPARED_STATEMENT_CACHE_SIZE);
+  const canonicalSchemas = opts.canonicalSchemas;
+  const canonicalNames = new Set(canonicalSchemas);
+  const logicalName = opts.logicalName;
+
+  // Caches live at pool scope (shared across checkouts). `needs` depends only on
+  // the text; the rewrite result is disambiguated per tenant via tenantTag.
+  const needsCache = new LruCache<boolean>(maxMemoEntries);
+  const rewriteCache = new LruCache<string>(maxMemoEntries);
+
+  const needsRewrite = (text: string): boolean => {
+    if (needsCache.has(text)) return needsCache.get(text);
+    const result = containsQuotedIdentifier(text, canonicalNames);
+    needsCache.set(text, result);
+    return result;
+  };
+
+  const rewriteText = (tenantTag: string, text: string, map: Map<string, string>): string => {
+    const key = tenantTag + ' ' + text;
+    if (rewriteCache.has(key)) {
+      counters.rewrittenQueries += 1;
+      counters.memoHits += 1;
+      return rewriteCache.get(key);
+    }
+    const out = rewriteQuotedIdentifiers(text, map);
+    rewriteCache.set(key, out);
+    counters.rewrittenQueries += 1;
+    return out;
+  };
+
+  // We rename prepared statements to bp_<hash>, which defeats the adaptor's own
+  // dispose (it keys its LRU by the ORIGINAL name, but pg's parsedStatements is
+  // now keyed by our hashed name, so its `deallocate <original>` never fires).
+  // So the wrapper OWNS the lifecycle: an insertion-ordered LRU of hashed names,
+  // kept on the RAW client so it survives release, evicts the oldest and fires a
+  // best-effort DEALLOCATE for it once the per-connection cap is exceeded.
+  const trackPreparedName = (rawClient: any, hashedName: string): void => {
+    if (maxPreparedNames <= 0) return;
+    let store: Map<string, true> = rawClient[BP_PREPARED];
+    if (!store) {
+      store = new Map();
+      rawClient[BP_PREPARED] = store;
+    }
+    if (store.has(hashedName)) {
+      // Refresh recency.
+      store.delete(hashedName);
+      store.set(hashedName, true);
+      return;
+    }
+    store.set(hashedName, true);
+    if (store.size > maxPreparedNames) {
+      const evicted = store.keys().next().value;
+      store.delete(evicted);
+      // Fire-and-forget on the raw connection (hashed names need no escaping).
+      Promise.resolve(rawClient.query('deallocate "' + evicted + '"'))
+        .then(() => {
+          // Mirror the adaptor's dispose: node-postgres tracks prepared names in
+          // connection.parsedStatements. Without clearing the entry, re-preparing
+          // the evicted name later would skip the Parse step and fail on PG with
+          // "prepared statement does not exist".
+          const parsed = rawClient.connection?.parsedStatements;
+          if (parsed) delete parsed[evicted];
+        })
+        .catch((err: any) => {
+          // eslint-disable-next-line no-console
+          console.error('[rewrite-pool] failed to deallocate prepared statement ' + evicted, err);
+        });
+    }
+  };
+
+  // Parse the adaptor's pgSettings query and (re)build the checkout's tenant map.
+  const applySettings = (text: string, values: any[], state: CheckoutState): void => {
+    // Defense in depth: only the adaptor's fixed settings statement may mutate
+    // checkout tenant state. The call site already gates on this text; guard again
+    // so no stray query whose parameter merely contains the GUC substring can
+    // suppress rewriting or remap the checkout via parameter contents alone.
+    if (!isSettingsText(text)) return;
+    counters.settingsParses += 1;
+
+    let tenantSchemas: string[] | null = null;
+    try {
+      const parsed = JSON.parse(values[0]);
+      let raw: any;
+      if (Array.isArray(parsed)) {
+        for (const entry of parsed) {
+          if (Array.isArray(entry) && entry[0] === POOL_SCHEMAS_GUC) {
+            raw = entry[1];
+            break;
+          }
+        }
+      } else if (parsed && typeof parsed === 'object') {
+        raw = parsed[POOL_SCHEMAS_GUC];
+      }
+      if (typeof raw === 'string') tenantSchemas = JSON.parse(raw);
+      else if (Array.isArray(raw)) tenantSchemas = raw;
+    } catch {
+      tenantSchemas = null;
+    }
+
+    if (!Array.isArray(tenantSchemas)) {
+      state.tenantMap = null;
+      state.tenantTag = null;
+      state.invalidReason = `malformed ${POOL_SCHEMAS_GUC} value`;
+      return;
+    }
+
+    const tenantByLogical = new Map<string, string>();
+    for (const t of tenantSchemas) tenantByLogical.set(logicalName(t), t);
+
+    const map = new Map<string, string>();
+    for (const c of canonicalSchemas) {
+      const logical = logicalName(c);
+      const t = tenantByLogical.get(logical);
+      if (t === undefined) {
+        state.tenantMap = null;
+        state.tenantTag = null;
+        state.invalidReason = `canonical schema "${c}" (logical "${logical}") has no tenant schema in [${tenantSchemas.join(', ')}]`;
+        return;
+      }
+      if (t !== c) map.set(c, t);
+    }
+
+    state.tenantMap = map;
+    state.invalidReason = null;
+    if (map.size === 0) {
+      // Canonical tenant querying itself: identity mode, no rewriting/namespacing.
+      state.tenantTag = null;
+    } else {
+      state.tenantTag = sha256hex([...tenantSchemas].sort().join(',')).slice(0, 16);
+    }
+  };
+
+  const failClosed = (state: CheckoutState, args: any[]): any => {
+    counters.failClosed += 1;
+    const reason = state.invalidReason ?? 'no tenant schema mapping has been applied to this connection';
+    const err = new Error(
+      `[rewrite-pool] pooled query requires a tenant mapping but none is established on this connection: ${reason}`
+    );
+    const last = args[args.length - 1];
+    if (typeof last === 'function') {
+      last(err);
+      return undefined;
+    }
+    return Promise.reject(err);
+  };
+
+  const interceptQuery = (rawQuery: any, thisArg: any, args: any[], state: CheckoutState): any => {
+    const first = args[0];
+
+    // Introspection filter (runs BEFORE settings parsing and any needs-rewrite /
+    // fail-closed logic). The introspection statement carries schema names only
+    // as string literals, so the identifier rewrite pass never applies to it —
+    // we forward the swapped text directly, bypassing rewriting entirely.
+    if (state.introspectionInterceptor) {
+      let iText: string | undefined;
+      if (typeof first === 'string') iText = first;
+      else if (first && typeof first === 'object' && typeof first.text === 'string') iText = first.text;
+      if (iText !== undefined && isIntrospectionQuery(iText)) {
+        // A callback-form introspection query would break callback semantics if
+        // rewritten async — pass it through unfiltered and count it.
+        if (typeof args[args.length - 1] === 'function') {
+          noteIntrospectionCallbackPassthrough();
+          return rawQuery.apply(thisArg, args);
+        }
+        const swap = state.introspectionInterceptor(iText, {
+          query: (sql: string, values?: any[]) => thisArg.query(sql, values)
+        });
+        if (swap !== null) {
+          return Promise.resolve(swap).then((swapped: string) => {
+            if (swapped === iText) return rawQuery.apply(thisArg, args);
+            if (typeof first === 'string') {
+              return rawQuery.apply(thisArg, [swapped, ...args.slice(1)]);
+            }
+            return rawQuery.apply(thisArg, [{ ...first, text: swapped }, ...args.slice(1)]);
+          });
+        }
+        // swap === null: filter disabled / no served schemas — fall through.
+      }
+    }
+
+    let text: string;
+    let values: any;
+    let name: any;
+    let isConfig = false;
+
+    if (typeof first === 'string') {
+      text = first;
+      if (Array.isArray(args[1])) values = args[1];
+    } else if (first && typeof first === 'object' && typeof first.text === 'string') {
+      isConfig = true;
+      text = first.text;
+      values = first.values;
+      name = first.name;
+    } else {
+      // Unknown shape (e.g. a Submittable) — forward untouched.
+      return rawQuery.apply(thisArg, args);
+    }
+
+    // Settings query: parse tenant identity, forward the query itself untouched.
+    // Classification keys on the adaptor's fixed statement TEXT (plus the GUC-bearing
+    // value shape), never on parameter contents alone — a data query carrying a
+    // user-controlled value that contains the GUC substring has different text and
+    // therefore falls through to the needs-rewrite / fail-closed path below.
+    if (isSettingsText(text) && isSettingsValues(values)) {
+      applySettings(text, values, state);
+      return rawQuery.apply(thisArg, args);
+    }
+
+    let newText = text;
+    if (needsRewrite(text)) {
+      if (state.invalidReason !== null || state.tenantMap === null) {
+        return failClosed(state, args);
+      }
+      if (state.tenantMap.size > 0) {
+        newText = rewriteText(state.tenantTag, text, state.tenantMap);
+      }
+      // else identity mode: leave text unchanged.
+    }
+
+    // Prepared-statement name namespacing (config form only). thisArg is the raw
+    // client on the checkout path (the only path where tenantTag is ever set), so
+    // the per-connection prepared-name LRU hangs off it.
+    let newName = name;
+    if (isConfig && name != null && state.tenantTag !== null) {
+      newName = hashName(state.tenantTag, String(name));
+      counters.nameRewrites += 1;
+      trackPreparedName(thisArg, newName);
+    }
+
+    if (newText === text && newName === name) {
+      return rawQuery.apply(thisArg, args);
+    }
+
+    // Clone rather than mutate the caller's object.
+    if (isConfig) {
+      const cloned = { ...first, text: newText };
+      if (newName !== name) cloned.name = newName;
+      return rawQuery.apply(thisArg, [cloned, ...args.slice(1)]);
+    }
+    return rawQuery.apply(thisArg, [newText, ...args.slice(1)]);
+  };
+
+  const introspectionFilter = opts.introspectionFilter;
+
+  const wrapClient = (client: any): any => {
+    const state = freshState();
+    // Per-checkout introspection interceptor: memoizes the closure discovery so a
+    // single build's introspection is filtered once and reused. A fresh interceptor
+    // per checkout keeps the memo connection-scoped.
+    if (introspectionFilter && Array.isArray(introspectionFilter.servedSchemas)) {
+      state.introspectionInterceptor = createIntrospectionInterceptor({
+        servedSchemas: introspectionFilter.servedSchemas
+      });
+    }
+    return new Proxy(client, {
+      get(target, prop, receiver) {
+        if (prop === 'query') {
+          return (...args: any[]) => interceptQuery(target.query, target, args, state);
+        }
+        if (prop === 'release') {
+          return (...args: any[]) => {
+            // Per-checkout state must not leak into the next borrower.
+            state.tenantMap = null;
+            state.tenantTag = null;
+            state.invalidReason = null;
+            state.introspectionInterceptor = null;
+            return target.release.apply(target, args);
+          };
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === 'function' ? value.bind(target) : value;
+      }
+    });
+  };
+
+  return new Proxy(pool, {
+    get(target, prop, receiver) {
+      if (prop === 'connect') {
+        return (...args: any[]) => {
+          // Callback style: connect((err, client, release) => ...)
+          if (typeof args[0] === 'function') {
+            const cb = args[0];
+            return target.connect((err: any, client: any, done: any) => {
+              if (err) {
+                cb(err, client, done);
+                return;
+              }
+              cb(err, wrapClient(client), done);
+            });
+          }
+          // Promise style (used by the PostGraphile adaptor).
+          return Promise.resolve(target.connect(...args)).then((client: any) => wrapClient(client));
+        };
+      }
+      if (prop === 'query') {
+        // Pool-level one-shot: no established checkout => tenantMap stays null,
+        // so anything needing a rewrite fails closed; everything else passes.
+        return (...args: any[]) => interceptQuery(target.query, target, args, freshState());
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === 'function' ? value.bind(target) : value;
+    }
+  });
+}
diff --git a/graphql/server/src/server.ts b/graphql/server/src/server.ts
index a88b48d9f4..3aad1050c1 100644
--- a/graphql/server/src/server.ts
+++ b/graphql/server/src/server.ts
@@ -10,11 +10,12 @@ import express, { Express, NextFunction, Request, RequestHandler, Response } fro
 import type { Server as HttpServer } from 'http';
 import graphqlUpload from 'graphql-upload';
 import { Pool, PoolClient } from 'pg';
-import { graphileCache, closeAllCaches } from 'graphile-cache';
+import { closeAllCaches, getMemoryPressure, graphileCache, startMemoryGovernor } from 'graphile-cache';
 import { getPgPool } from 'pg-cache';
 import requestIp from 'request-ip';
 
 import type { DebugSamplerHandle } from './diagnostics/debug-sampler';
+import { installConnectionErrorGuard } from './diagnostics/connection-error-guard';
 import { closeDebugDatabasePools } from './diagnostics/debug-db-snapshot';
 import {
   isDevelopmentObservabilityMode,
@@ -40,6 +41,7 @@ import { parseCookieValue, SESSION_COOKIE_NAME } from './middleware/cookie';
 import { createAgenticRouter } from 'agentic-server';
 import { createContextMiddleware, requestIdMiddleware } from '@constructive-io/express-context';
 import { startDebugSampler } from './diagnostics/debug-sampler';
+import { collectMetricsSample, type MetricsSamplerHandle, startMetricsSampler } from './diagnostics/metrics-sampler';
 
 const log = new Logger('server');
 
@@ -80,8 +82,11 @@ class Server {
   private closed = false;
   private httpServer: HttpServer | null = null;
   private debugSampler: DebugSamplerHandle | null = null;
+  private metricsSampler: MetricsSamplerHandle | null = null;
+  private stopGovernor: (() => void) | null = null;
 
   constructor(opts: ConstructiveOptions) {
+    installConnectionErrorGuard();
     this.opts = getEnvOptions(opts);
     const effectiveOpts = this.opts;
     const observabilityRequested = isGraphqlObservabilityRequested();
@@ -126,6 +131,15 @@ class Server {
     }
 
     healthz(app);
+    // Operational metrics endpoint (heap/rss, cache size, build/eviction/guard
+    // counters, memory pressure) — same sample shape as the JSON-line sampler.
+    // Env-gated and loopback-only by default; front it with internal routing in
+    // production if remote scrape access is needed.
+    if (process.env.GRAPHILE_METRICS_ENDPOINT === '1') {
+      app.get('/metrics', localObservabilityOnly, (_req, res) => {
+        res.json({ ...collectMetricsSample(), memoryPressure: getMemoryPressure() });
+      });
+    }
     if (observabilityEnabled) {
       app.get('/debug/memory', localObservabilityOnly, debugMemory);
       app.get('/debug/db', localObservabilityOnly, createDebugDatabaseMiddleware(effectiveOpts));
@@ -209,6 +223,14 @@ class Server {
 
     this.app = app;
     this.debugSampler = observabilityEnabled ? startDebugSampler(effectiveOpts) : null;
+    // Gated purely on GRAPHILE_DEBUG_METRICS (not dev-only observability): this JSON-line
+    // sampler is designed for long production soak analysis and is a true no-op when the
+    // env flag is off.
+    this.metricsSampler = startMetricsSampler();
+    // Proactive heap-pressure eviction (85%) + critical build refusal (92%) —
+    // the request-path gate lives in the graphile dispatcher; this timer only
+    // does the background evictions. Disable with GRAPHILE_MEMORY_GOVERNOR=0.
+    this.stopGovernor = startMemoryGovernor();
   }
 
   listen(): HttpServer {
@@ -320,6 +342,14 @@ class Server {
       await this.debugSampler.stop();
       this.debugSampler = null;
     }
+    if (this.metricsSampler) {
+      this.metricsSampler.stop();
+      this.metricsSampler = null;
+    }
+    if (this.stopGovernor) {
+      this.stopGovernor();
+      this.stopGovernor = null;
+    }
     if (this.httpServer?.listening) {
       await new Promise<void>((resolve) => this.httpServer!.close(() => resolve()));
     }
diff --git a/packages/express-context/src/types.ts b/packages/express-context/src/types.ts
index 39e0a79c56..f6a860a0e8 100644
--- a/packages/express-context/src/types.ts
+++ b/packages/express-context/src/types.ts
@@ -106,6 +106,12 @@ export interface ApiStructure {
   anonRole: string;
   roleName: string;
   schema: string[];
+  /**
+   * Logical schema names (tenant hash prefix stripped) derived from `schema`.
+   * Used by blueprint pooling to key a shared PostGraphile instance by
+   * schema-shape rather than by physical tenant schema.
+   */
+  logicalSchemas?: string[];
   apiModules: ApiModule[];
   rlsModule?: RlsModule;
   domains?: string[];
diff --git a/packages/perf-harness/.gitignore b/packages/perf-harness/.gitignore
new file mode 100644
index 0000000000..c71e46e3f3
--- /dev/null
+++ b/packages/perf-harness/.gitignore
@@ -0,0 +1,3 @@
+dist/
+.smoke-out/
+perf-out/
diff --git a/packages/perf-harness/DESIGN.md b/packages/perf-harness/DESIGN.md
new file mode 100644
index 0000000000..faf0846ec4
--- /dev/null
+++ b/packages/perf-harness/DESIGN.md
@@ -0,0 +1,168 @@
+# @constructive-io/perf-harness — Design
+
+Reusable performance / regression harness for the Constructive GraphQL server.
+Port of the ad-hoc `scripts/scale-validate/*.mjs` tooling (built during the
+2026-07 blueprint-pooling validation program) into a proper monorepo package,
+so the next time a memory/scale regression appears it is re-run with one
+command instead of hand-driven scripts.
+
+**The originals in `scripts/scale-validate/` are the behavioral source of
+truth. Port faithfully: every CLI flag, default, output field, and exit code is
+preserved unless this document says otherwise. Do not redesign algorithms.**
+
+## Package identity
+
+- Directory: `packages/perf-harness` (auto-included by `pnpm-workspace.yaml` glob `packages/*`; lerna derives from pnpm — no registration anywhere)
+- Name: `@constructive-io/perf-harness`, version `0.1.0`, license MIT, author `Constructive <developers@constructive.io>`
+- Bin: `{ "perf-harness": "index.js", "cperf": "index.js" }` (dist-relative like `packages/cli`; shebang `#!/usr/bin/env node` as FIRST line of `src/index.ts` — makage preserves it; no makage config file exists or is needed)
+- `main: index.js`, `module: esm/index.js`, `types: index.d.ts`, `publishConfig: { access: public, directory: dist }`, NO `files` field (no sibling has one)
+- Scripts (verbatim sibling standard):
+  `clean: makage clean` / `prepack: npm run build` / `build: makage build` / `build:dev: makage build --dev` / `dev: ts-node ./src/index.ts` / `lint: eslint . --fix` / `test: jest --passWithNoTests` / `test:watch: jest --watch`
+- dependencies: `pg ^8.21.0` (imported directly), `inquirerer ^4.9.1`, `@inquirerer/utils ^3.3.9`, `graphile-cache workspace:^` (lazy-required ONLY inside `report predict` — see below)
+- devDependencies: `@types/pg ^8.20.0`, `@types/node ^22.19.11`, `makage ^0.3.0`, `ts-node ^10.9.2`, `@inquirerer/test ^1.4.3`
+- Do NOT declare typescript / jest / ts-jest / eslint / graphql — root-hoisted or irrelevant.
+- `tsconfig.json`, `tsconfig.esm.json`, `jest.config.js`: byte-identical to `packages/server-utils` versions (extends `../../tsconfig.json`; ESM variant outDir `dist/esm`, module es2022, declaration false; jest = ts-jest preset, testRegex `(/__tests__/.*|(\.|/)(test|spec))\.(jsx?|tsx?)$`, modulePathIgnorePatterns `['dist/*']`, NO trailing commas).
+- NO eslint config file in the package (root `.eslintrc.json` governs). Code style: 2-space, single quotes, semicolons, no trailing commas, `_`-prefixed unused args.
+
+## Hard rules (safety + fidelity)
+
+1. **Hub guardrail**: `HUB_PORTS = [5432, 3000, 3001, 3002, 9000]`. EVERY command that dials Postgres or a server port calls `assertPortAllowed(port, allowHub)` and fails with a clear error naming the flag `--allow-hub` to override. PG port default is **5433, never 5432** (preserve the `_lib.mjs` comment's intent).
+2. **Credentials**: never hardcoded. `--email` defaults to `seeder@gmail.com`; `--password` has NO default — resolution order: flag > `PERF_PASSWORD` env. Commands needing auth error out with guidance when it is missing. Never interpolate creds into shell strings (we spawn with arg arrays only).
+3. **No absolute paths** in code. Repo root discovered by walking up from cwd to the first `pnpm-workspace.yaml` (`findRepoRoot()`); server command defaults to `['node', '<repoRoot>/packages/cli/dist/index.js']`, overridable via `--server-cmd`.
+4. All outputs under `--out-dir` (default `./perf-out`), created with mkdir -p. File naming: `metrics-<label>.jsonl`, `harness-<label>.json`, `pg-<label>.jsonl`, `<label>-results.jsonl`, `<name>.log`, `<name>.pid`, `<name>.done`.
+5. Exit codes preserved: harness `0` ok / `1` fatal / `2` bleed-sentinel violation. Regression: `0` pass / `1` fail / `2` bleed.
+6. TypeScript per root config (`strict: true`, `strictNullChecks: false`). `any` is allowed. Plain `console` for CLI output — stdout is reserved for machine-readable JSON/JSONL protocol lines exactly like the originals; human logs go to stderr where the originals did.
+
+## Module layout & interface contract
+
+Domain modules code against these EXACT `core/` signatures (foundation implements them; behavior ports from `scripts/scale-validate/_lib.mjs` unless noted).
+
+```
+src/
+  index.ts               CLI entry (shebang) — routes `perf-harness <domain> <sub> [flags]`
+  commands/{fleet,load,measure,run,report,regression}.ts
+  core/{args,config,rng,histogram,gql,pgc,proc,fleetfile}.ts
+  fleet/{discover,provision,drift,canary,teardown}.ts
+  load/{harness,churn}.ts
+  measure/{collector,pgSampler,instanceHeap}.ts
+  run/{server,ramp,soak,soakOps}.ts
+  report/{summarize,merge,predict}.ts
+  regression/{suite,baselines,compare}.ts
+  __tests__/  (per-domain, colocated under src/<domain>/__tests__/)
+```
+
+### core/args.ts  (port of _lib parseArgs + coercions)
+```ts
+export type Argv = Record<string, any> & { _: string[] };
+export function parseArgv(raw: string[]): Argv;          // --flag value | --flag=value | --flag → true; positionals into _
+export function asBool(v: any, dflt?: boolean): boolean; // '1'|'true'|'yes'|'on'
+export function asInt(v: any, dflt?: number): number;
+export function asFloat(v: any, dflt?: number): number;
+export function usageExit(usage: string, code?: number): number; // prints usage, returns code
+```
+
+### core/config.ts
+```ts
+export interface PgConfig { host: string; port: number; user: string; password: string; database: string }
+export const HUB_PORTS: number[]; // [5432, 3000, 3001, 3002, 9000]
+export function assertPortAllowed(port: number, allowHub: boolean, what?: string): void; // throws Error mentioning --allow-hub
+export function pgConfigFromArgv(argv: Argv): PgConfig;  // --pg-host/--pg-port/--pg-user/--pg-password/--pg-database > PGHOST/PGPORT/PGUSER/PGPASSWORD/PGDATABASE > localhost/5433/postgres/password/constructive; calls assertPortAllowed with asBool(argv['allow-hub'])
+export function findRepoRoot(startDir?: string): string; // walk up to pnpm-workspace.yaml; throws if not found
+export function resolveOutDir(argv: Argv): string;       // --out-dir default './perf-out', mkdir -p
+export function resolveServerCmd(argv: Argv, repoRoot: string): string[]; // --server-cmd (space-split) or default
+export function resolveCreds(argv: Argv): { email: string; password: string | null }; // --email/--password > PERF_PASSWORD
+```
+
+### core/rng.ts — `makeRng(seed)` (mulberry32), `makeZipfSampler(n, rng)`, `makeMixSampler(mixStr, rng)` — verbatim ports.
+
+### core/histogram.ts — `export class Histogram` with `record(ms)`, `percentile(p)`, `summary()` and the DEFAULT_BUCKETS table, verbatim port.
+
+### core/gql.ts — verbatim ports of `gqlFetch` (host-in-URL trick, AbortController timeout, Bearer token), `INTROSPECTION_QUERY`, `isRotating`, `gqlErrors`, `isUnauthenticated`, `unwrapType`, `isNonNull`, `buildTypeIndex`, `discoverOps`, `buildCreateRecord` (+ `export interface GqlResponse { status: number; ok: boolean; json?: any; text?: string; elapsedMs: number; error?: string }` and a `DiscoveredOps` interface matching discoverOps' return).
+
+### core/pgc.ts
+```ts
+export function getPg(): { Client: any; Pool: any };     // = require('pg') — real dependency now, NOT the resolvePg chain
+export function withFreshClient<T>(pg: PgConfig, fn: (client: any) => Promise<T>): Promise<T>; // connect/fn/end in finally
+export function isConnLoss(err: any): boolean;           // 57P01/57P02/57P03/08006/08003/53300 + message sniff (port from tenant-factory)
+export function isRetryableTxn(err: any): boolean;       // 40P01/40001
+```
+
+### core/proc.ts (new — replaces the nohup/python-setsid launcher pattern AND the inline child management)
+```ts
+export interface SpawnDetachedOpts { name: string; cmd: string; args: string[]; env?: Record<string, string>; cwd?: string; outDir: string }
+export function spawnDetached(o: SpawnDetachedOpts): { pid: number; logPath: string; pidPath: string }; // spawn(detached:true, stdio ['ignore', logFd, logFd]), unref(), write <outDir>/<name>.pid
+export function isAlive(pid: number): boolean;                       // kill(pid, 0)
+export function stopPid(pid: number, termTimeoutMs?: number): Promise<'term' | 'kill' | 'gone'>; // SIGTERM → poll → SIGKILL (default 15000)
+export function readPid(outDir: string, name: string): number | null;
+export function waitForPort(port: number, timeoutMs: number): Promise<void>; // probe BOTH 127.0.0.1 and ::1 (macOS binds ::1)
+export function readJsonl(file: string): any[];                      // parse-guarded per line
+export function writeDone(outDir: string, name: string, content?: string): void;
+```
+
+### core/fleetfile.ts
+```ts
+export interface Tenant { dbname: string; databaseId?: string; apiHost?: string; authHost?: string; schemas?: string[]; appPublicSchema?: string }
+export function loadFleet(file: string): { manifest: any; tenants: Tenant[] };  // array | {tenants}; throws if empty
+export const CANARY_PREFIX: string;  // 'CANARY-'
+export function canaryName(t: Tenant): string;
+export interface SubsetOpts { blueprints?: number; perBlueprint?: number; tenants?: number; sameBpRegex?: string }
+export function buildSubset(fleet: Tenant[], drifted: { groups?: Record<string, string[]>; columnDrift?: string[] }, o: SubsetOpts): { subset: any; tenants: Tenant[]; warnings: string[] }; // pure port of subset-fleet.mjs
+```
+
+### run/server.ts (shared by ramp / soak / instanceHeap)
+```ts
+export interface ServerSpawnOpts { name: string; port: number; heapMb: number; metricsFile: string; pg: PgConfig; repoRoot: string; outDir: string; serverCmd?: string[]; cacheMax?: number; instanceHeapBytes?: number; metricsEndpoint?: boolean; extraEnv?: Record<string, string>; detached?: boolean; allowHub?: boolean }
+export function spawnServer(o: ServerSpawnOpts): Promise<{ pid: number; stop: () => Promise<void> }>;
+```
+Env it sets on the child (from the validated soak recipe): `NODE_ENV=production`, `NODE_OPTIONS=--max-old-space-size=<heapMb>`, `GRAPHILE_DEBUG_METRICS=1`, `GRAPHILE_DEBUG_METRICS_FILE=<metricsFile>`, `GRAPHILE_BLUEPRINT_POOLING=1`, `GRAPHILE_METRICS_ENDPOINT=1` when metricsEndpoint, `GRAPHILE_CACHE_MAX=<cacheMax>` when set, `GRAPHILE_CACHE_INSTANCE_HEAP_BYTES=<instanceHeapBytes>` when set, PG* from PgConfig, plus extraEnv. Args: `server --port <port> --origin * --simpleInflection --postgis --servicesApi`. Waits for the port (120s, dual-stack) before resolving.
+
+### Command registration contract
+Each `src/commands/<domain>.ts` exports:
+```ts
+export const domain: string;                       // e.g. 'fleet'
+export const summary: string;                      // one-liner for top-level help
+export interface Subcommand { usage: string; run(argv: Argv): Promise<number> }
+export const subcommands: Record<string, Subcommand>;
+```
+`src/index.ts` (CLI agent) routes `argv._[0]` → domain, `argv._[1]` → subcommand, prints composed help for `--help`/unknown, `process.exitCode = await run(argv)`. Prefer the `inquirerer` CLI shell as `packages/cli` uses it, BUT: never define interactive Questions (automation must not prompt); if nested subcommand routing fights the framework, a hand-rolled router over `parseArgv` is acceptable — working non-interactive CLI beats framework conformance.
+
+## Command tree (source .mjs in parentheses — preserve its flags)
+
+- `fleet discover` (fleet.mjs) · `fleet provision` (tenant-factory.mjs) · `fleet drift` (drift-tenants.mjs — REPLACE its inline pg/defaults with core; ADD --pg-* flag support + --help) · `fleet canary` (canary-seed.mjs) · `fleet subset` (subset-fleet.mjs; pure logic in core/fleetfile buildSubset) · `fleet teardown` (drop-tenants.mjs — keep GUC `constructive.allow_super_constructive`, partman part_config(_sub) cleanup, VACUUM ANALYZE list, `--dry-run`)
+- `load harness` (harness.mjs — THE critical port: token-bucket pacer, mix/shape samplers, auth signIn + token-field scoring, relogin scan, bleed sentinel w/ exit 2, rolling progress JSONL on stdout, SIGTERM-flushed final `--out` JSON, drain ≤15s) · `load churn` (churn-driver.mjs — fresh Client per NOTIFY, stop line on signal)
+- `measure collector` (collector.mjs — `ps -o rss=` sampling, metrics tail, last-half linreg slope MB/h, schema-tolerant counter pick) · `measure pg` (pg-sampler.mjs — docker stats + pg_stat_activity/pg_class/db size) · `measure instance-heap` (measure-instance-heap.mjs — fresh cap=1 server per class via run/server.ts, baseline→cold→settle→delta)
+- `run ramp` (v2-ramps.mjs — RampPlan `{ port?, defaults, steps[] }` typed interface, `cfg = {...defaults, ...step}`, fresh server per step, crash-tolerated-and-recorded, pg backend sampler w/ reconnect, cold-burst mode) · `run soak` — NEW orchestrator replacing run-soak-*.sh: `run soak start` spawns detached server + harness + churn + soak-ops + collector + pg-sampler (pid files), `run soak status` (pids alive, last harness progress line, /metrics snapshot), `run soak stop` (signal fan-out IN ORDER: harness → collector → churn → soak-ops → pg-sampler → server; then writes `<label>.done`) · `run soak-ops` (soak-ops.mjs — ADD the missing SIGTERM handler: finish current cycle child, then final-drop and exit)
+- `report summarize` (summarize-results.mjs) · `report merge` — NEW: merge server metrics JSONL + harness progress JSONL + churn/ops event lines + pg-sampler JSONL into one `report-data.json` (aligned time series, event markers, heap slope, counter deltas) + a markdown summary table printed to stdout · `report predict` — capacity/sizing: lazy `require('graphile-cache')` (typed via a minimal local declaration; the workspace dep exists but MUST NOT be imported at module top level — it pulls the PostGraphile chain into every CLI start) and call `computeCapacityFromBudget(heapLimitBytes, perInstanceBytes, baseReserve?, buildReserve?)`; print capacity + a small sizing table for a list of heap sizes
+- `regression run` — the one-command suite (below) · `regression baselines` — list known baselines
+
+## Regression suite (`regression run`)
+
+Flags: `--fleet <manifest>` (required), `--suite quick|standard` (default quick), `--baseline <name>` (default `catalog61k-2026-07`), `--port` (default 3345), `--heap-mb` (default 3584), `--out-dir`.
+Preflight: PG reachable, catalog `pg_class` count recorded, server dist exists, port free + allowed.
+Checks (each returns `{ name, pass, value, threshold, note }`):
+1. `instance-heap` (standard suite only): `measure instance-heap` on one tenant-api class → KB/pg_class-row ≤ `maxInstanceHeapKBPerRow`
+2. `healthy-single-bp`: ramp step vs same-shape subset at capacity → errRate ≤ 0.005, p99 ≤ 150ms, 0 bleed
+3. `zero-marginal-tenants`: two tenant-count steps (e.g. 10 vs max available) → heapMax delta ≤ 100MB
+4. `thrash-not-crash` (standard): over-capacity diversity step → server process must SURVIVE (crash = FAIL; degraded latency/errors are EXPECTED and not failures)
+5. `bleed`: sentinel violations across all steps == 0 (exit 2 anywhere → suite exit 2)
+Verdict: JSON (`regression-results.json`) + human table; exit 0/1/2.
+
+### regression/baselines.ts (typed const, from the 2026-07 program — V2-RESULTS.md/SIZING.md)
+```ts
+export interface Baseline { name: string; capturedAt: string; catalogPgClassRows: number; instanceHeapKBPerRow: number; pgIntrospectionSpikeKBPerRow: number; minViableHeapMB: number; baseReserveMB: number; buildReserveMB: number; zeroMarginal: { tenants: number[]; heapMaxMB: number[] }; healthy: { rps: number; p99Ms: number; errRate: number }; capacityByHeapMB: Record<string, number>; thresholds: { maxInstanceHeapKBPerRow: number; maxZeroMarginalDeltaMB: number; maxHealthyErrRate: number; maxHealthyP99Ms: number; maxHeapSlopeMBPerHour: number } }
+```
+Seed entry `catalog61k-2026-07`: rows 61238, 21 KB/row, 37 KB/row PG spike, minViable 1536, reserves 256/768, zeroMarginal tenants [10,20,32] → heapMax [1460.1, 1459.6, 1464.1], healthy { rps: 188, p99Ms: 21, errRate: 0 }, capacity { '2048': 1, '3584': 2 }, thresholds { 28, 100, 0.005, 150, 5 }.
+
+## Testing (default `jest` run needs NO network/PG/docker)
+
+Unit tests (fixtures inline or under `__tests__/fixtures/`): parseArgv/coercions; hub-guardrail (5432 throws, 5433 passes, --allow-hub overrides); mulberry32 determinism; zipf/mix samplers (seeded distributions); Histogram percentiles; buildSubset (diversity, tenant-count, warnings — pure JSON); linregSlope + pickCounter + flattenNumeric (collector); dockerMem toBytes; token-field scoring (scoreTokenField/findTokenSelection — export them from load/harness.ts); RampPlan cfg merge; summarize + merge on fixture JSONL; baseline comparator; canary valueForColumn; tenant-factory shape-fingerprint sha256 (fixture pairs) + retry classification. Anything needing a live server/PG: guard behind `process.env.PERF_E2E === '1'` with `describe.skip`-style gating.
+
+## README.md (the runbook)
+
+Must contain: 30-second "regression reappeared" quickstart (rig up via pgpm docker on a NON-hub port → `fleet provision` or existing fleet → `regression run --fleet ...`); the full soak recipe (`run soak start/status/stop`); a metrics-tracking section (what each artifact file is: metrics JSONL fields incl. counters.connGuard/evictions, /metrics endpoint + loopback gating, pg-sampler line, collector summary, report merge output); the sizing model one-liner (capacity law + 21KB/row + 37KB/row constants, shard-per-PG-database guidance); env knob table (GRAPHILE_* from the instrument recon); hub-safety note; creds via PERF_PASSWORD.
+
+## Out of scope (deliberate)
+
+- Do NOT modify or delete `scripts/scale-validate/` (a live soak uses it; retirement happens later).
+- Do NOT touch `graphql/server` / `graphile-cache` source.
+- No CI wiring in this pass.
diff --git a/packages/perf-harness/README.md b/packages/perf-harness/README.md
new file mode 100644
index 0000000000..14259b3001
--- /dev/null
+++ b/packages/perf-harness/README.md
@@ -0,0 +1,465 @@
+# @constructive-io/perf-harness
+
+Reusable performance / regression harness for the Constructive GraphQL server
+(`cnc server` / PostGraphile v5 with blueprint pooling).
+
+It is the packaged form of the ad-hoc `scripts/scale-validate/*.mjs` tooling built
+during the 2026-07 blueprint-pooling scale-validation program. When a memory or
+scale regression reappears, re-run it with **one command** instead of hand-driving
+scripts.
+
+Binary: `perf-harness` (alias `cperf`). Everything is non-interactive — it never
+prompts, so it is safe in CI and unattended soaks.
+
+```
+perf-harness <domain> <subcommand> [flags]
+```
+
+| Domain | What it does |
+|---|---|
+| `fleet` | discover / provision / drift / canary / subset / teardown tenant fleets |
+| `load` | `harness` (paced authenticated workload + cross-tenant bleed sentinel), `churn` (NOTIFY schema:update driver) |
+| `measure` | `collector` (RSS + metrics tail), `pg` (Postgres-side sampler), `instance-heap` (per-blueprint resident heap) |
+| `run` | `ramp` (multi-step regime sweep), `soak` (`start`/`status`/`stop` orchestrator), `soak-ops` (provision/teardown cycler) |
+| `report` | `summarize` (per-step ramp results), `merge` (unified time series), `predict` (capacity / sizing) |
+| `regression` | `run` (one-command pass/fail suite), `baselines` (list known baselines) |
+
+Run `perf-harness <domain> --help` for a domain's subcommands.
+
+---
+
+## 30-second quickstart — "the regression is back"
+
+Everything runs against an **isolated** Postgres and an **isolated** server port so
+it can never touch a running hub (see [Hub safety](#hub-safety)). The rig used
+throughout the program is Postgres on **:5433** in container `constructive-scale-pg`.
+
+```bash
+# 0. credentials (never passed on the command line / interpolated into shells)
+export PERF_PASSWORD='…'          # seeder password; --email defaults to seeder@gmail.com
+
+# 1. bring up an isolated Postgres on a NON-hub port (5433, never 5432)
+pgpm docker start --recreate      # then point PG* at it:
+export PGHOST=localhost PGPORT=5433 PGUSER=postgres PGPASSWORD=password PGDATABASE=constructive
+
+# 2. a fleet: reuse an existing manifest, or provision fresh tenants
+perf-harness fleet provision --count 10 --prefix factory --blueprint marketplace
+perf-harness fleet discover  --like 'marketplace%' --out perf-out/fleet.json
+perf-harness fleet canary    --fleet perf-out/fleet.json         # seed bleed canaries
+
+# 3. run the regression suite (builds a fresh server, ramps, verdicts, tears down)
+perf-harness regression run --fleet perf-out/fleet.json --suite quick
+echo "exit=$?"                     # 0 pass · 1 fail · 2 cross-tenant bleed
+```
+
+`regression run` preflights (PG reachable, catalog `pg_class` count recorded, server
+dist present, port free + allowed), then evaluates each check
+`{ name, pass, value, threshold, note }` against the baseline (default
+`catalog61k-2026-07`) and writes `regression-results.json` plus a human table.
+
+Suite flags: `--fleet <manifest>` (required) · `--suite quick|standard|deep` (default
+`quick`) · `--baseline <name>` · `--port` (default 3345) · `--heap-mb` (default
+3584) · `--deep-heap-mb` (default 7168, `deep` only) · `--out-dir` (default
+`./perf-out`) · `--only`/`--skip` (deep-check filter).
+
+Checks: `healthy-single-bp` (errRate ≤ 0.005, p99 ≤ 150ms, 0 bleed) ·
+`zero-marginal-tenants` (heapMax delta ≤ 100MB across tenant counts) · `bleed`
+(sentinel violations == 0). The `standard` suite adds `instance-heap`
+(≤ 28 KB/pg_class row) and `thrash-not-crash` (over-capacity step must **survive** —
+degraded latency/errors are expected, a crashed process is the only failure). The
+`deep` suite adds four rig-mutating scenarios that cover the axes the other suites
+never touch — see [Deep suite](#deep-suite).
+
+---
+
+## Deep suite
+
+**`--suite deep`** runs everything in `standard` **plus** four scenarios that exercise
+scaling axes the quick/standard checks never touch: multiple hot API surfaces on one
+node, settings-driven pool splits, the cost of a realtime (unpoolable) tenant, and
+catalog creep from `pg_partman`. Unlike the other suites these checks **mutate the
+rig** — they `INSERT` `services_public.database_settings` rows and `CREATE` a
+partition — so each one is wrapped in `try/finally` teardown that returns the rig
+**exactly** to how it was found, each is individually selectable via `--only`/`--skip`,
+its mutating SQL is kept minimal and reversible, and every Postgres/server dial still
+goes through the [hub guardrail](#hub-safety) (`--allow-hub` to override; PG on
+:5433). `--deep-heap-mb` (default **7168**) sizes the server for the multi-API check,
+which needs capacity ≥ 4; the other checks run at the normal `--heap-mb`.
+
+Two of the four can fail the suite (exit 1); the other two are **advisory** — they
+report pass/fail and record their findings but **never** change the verdict or exit
+code (`bleed` remains the only exit-2 trigger):
+
+| Check | Advisory? | Asserts |
+|---|---|---|
+| `multi-api-residency` | no | 4 surfaces resident, 0 evictions, heap ≈ base + 4×I |
+| `settings-variant-split` | no | a settings row forks a 2nd pooled instance; both serve errRate 0 |
+| `realtime-dedicated-cost` | **yes** | a realtime tenant is unpoolable (or captures why it cannot build) |
+| `partition-creep` | **yes** | rows added per partition → projected catalog/heap creep per tenant per month |
+
+### `multi-api-residency` (R=4)
+
+Using 8–10 same-blueprint tenants, it derives one fleet **per surface** by rewriting
+each tenant's `apiHost` to its `admin-…` / `usage-…` host (those domains exist on the
+rig; the `auth-…` host stays for login). At `--deep-heap-mb` (capacity ≥ 4 — verified
+via `computeCapacityFromBudget` or `/metrics`) it cold-builds all four surfaces (api,
+auth via login, admin, usage), then holds all four **hot** for ~120s (a light
+`gqlFetch` loop per surface every 1–2s; the harness child on the api fleet optionally
+supplies the main load). **Asserts** the cache reaches size 4 with **zero LRU
+evictions** during the hold, every surface keeps answering (a 2xx / valid GraphQL
+response on a meta/introspection-safe op), and `heapUsed` plateaus at base + 4×I within
+±20% (`multiApiHeapTolerance`). Records the measured heap-per-instance. Informational
+sub-assert: repeated at heap 3584 (capacity 2), the same four-surface pattern must show
+eviction **churn without process death** — thrash-not-crash at the surface level.
+
+### `settings-variant-split`
+
+`INSERT`s `services_public.database_settings` rows with `enable_aggregates=true` (every
+other column left at its declared default) for exactly **2** same-blueprint tenants,
+triggers them to take effect (a `pg_notify` on `schema:update` carrying those
+`databaseId`s, or the documented flush), then drives one variant tenant and one control
+tenant on the api surface. **Asserts** two **distinct** pooled instances for the same
+relation shape (the builds counter climbs by 2 for the api surface, or the cache-key
+count shows the split) and both groups serve errRate 0 (`settingsSplitExpectedInstances`
+= 2). **Teardown** `DELETE`s the rows and re-flushes, then verifies the pool
+**re-collapses** (or documents the one extra rebuild). If the flush does not pick the
+settings up, the check asserts whatever the recon establishes as the actual contract and
+is marked advisory.
+
+### `realtime-dedicated-cost` (advisory)
+
+`INSERT`s a `database_settings` row with `enable_realtime=true` for **one** tenant,
+flushes, and hits that tenant's api host. Per
+`graphql/server/src/middleware/pooling-decision.ts` a realtime service is unpoolable,
+so the check **either** asserts a dedicated instance (pooling refused — the cache gains
+a non-blueprint key / the pooling-attach counter does not tick for it) and measures its
+heap cost, **or**, if the server cannot build realtime without the module infra,
+captures the exact failure mode as the check result (that is useful data, not a suite
+failure). Either way it confirms the other tenants stay pooled and serving. **Teardown**
+`DELETE`s the row, re-flushes, and verifies the tenant returns to pooled serving.
+Advisory: never flips the verdict.
+
+### `partition-creep` (advisory)
+
+A pure-SQL measurement — **no server**. It reads the `partman.part_config` rows for one
+tenant's schema set (`parent_table LIKE '<tenant-schema>%'`), records each parent's
+`partition_interval` and `premake`, `CREATE`s exactly one additional future partition
+for one `events` parent (via the partman API, or a plain `CREATE TABLE … PARTITION OF`
+with the correct bounds), and measures the `pg_class` row delta for that one partition
+(table + indexes + toast). **Teardown** `DROP`s the partition and verifies the delta
+returns to zero. From rows-per-partition × partitioned-parents-per-tenant ×
+partitions-per-interval it projects catalog rows/tenant/month and, at 22KB/row, heap
+creep MB/tenant/month. Reported as informational against a generous advisory threshold
+(`partitionCreepMaxRowsPerTenantMonth` = 200). Advisory: never flips the verdict.
+
+The four scenarios live in `src/regression/scenarios.ts` (SQL helpers in
+`src/regression/sql.ts`), registered behind the `deep` tier. The baseline
+(`catalog61k-2026-07`) gains deep thresholds `multiApiHeapTolerance: 0.2` ·
+`settingsSplitExpectedInstances: 2` · `partitionCreepMaxRowsPerTenantMonth: 200` and
+expected constants `apiSurfacesRoutable: 8` · `instanceHeapKBPerRow: 21`.
+
+---
+
+## Full soak recipe
+
+A soak is a long-running background rig: one detached server plus five detached
+workers, each with its own `<name>.pid` / `<name>.log` under `--out-dir`.
+
+```bash
+# start: spawns server + harness + churn + soak-ops + collector + pg-sampler (detached)
+perf-harness run soak start \
+  --fleet perf-out/fleet.json --label v3 \
+  --port 3333 --heap-mb 3584 --duration-sec 18000 --out-dir perf-out
+
+# status: pids alive? + last harness progress line + /metrics snapshot
+perf-harness run soak status --label v3 --out-dir perf-out
+
+# stop: ordered signal fan-out, then writes <label>.done
+perf-harness run soak stop --label v3 --out-dir perf-out
+```
+
+`stop` signals the workers **in this order** so the workload quiesces before the
+data collectors and the server go down (and provisioning/teardown finishes its
+current cycle cleanly):
+
+```
+harness → collector → churn → soak-ops → pg-sampler → server
+```
+
+then writes `<label>.done`. Each worker flushes on `SIGTERM`: the harness drains
+in-flight requests (≤ 15s) and writes its final `harness-<label>.json`; `soak-ops`
+finishes the current provision/teardown cycle and drops its last tenant so the
+fleet returns to baseline; the pg-sampler and metrics JSONL are append-per-line
+(nothing to flush).
+
+The server the soak launches gets the validated recipe: `NODE_ENV=production`,
+`NODE_OPTIONS=--max-old-space-size=<heap-mb>`, `GRAPHILE_DEBUG_METRICS=1` +
+`GRAPHILE_DEBUG_METRICS_FILE=<metrics-…>`, `GRAPHILE_BLUEPRINT_POOLING=1`,
+`GRAPHILE_METRICS_ENDPOINT=1`, and `GRAPHILE_CACHE_*` when set, with args
+`server --port <port> --origin * --simpleInflection --postgis --servicesApi`.
+
+---
+
+## Metrics tracking — what each artifact is
+
+All artifacts land under `--out-dir` (default `./perf-out`, created `mkdir -p`).
+File naming is `<kind>-<label>` so a soak's files group together:
+
+| File | Producer | Contents |
+|---|---|---|
+| `metrics-<label>.jsonl` | server (`GRAPHILE_DEBUG_METRICS`) | ~10s server self-report lines (below) |
+| `harness-<label>.json` | `load harness` | final workload report + all rolling progress lines |
+| `pg-<label>.jsonl` | `measure pg` | one Postgres-side sample per interval |
+| `<name>.json` (collector) | `measure collector` | RSS series + slope + metrics counter totals |
+| `<label>-results.jsonl` | `run ramp` | one JSON object per ramp step |
+| `report-data.json` | `report merge` | aligned, merged time series across all of the above |
+| `<name>.log` / `.pid` / `.done` | `run soak` | per-worker stdout+stderr / pid / completion marker |
+
+### Server metrics JSONL — `metrics-<label>.jsonl`
+
+The schema is owned by the server instrumentation; the harness treats it as
+schema-tolerant (flattens the last line, picks the best numeric per counter
+family). Each ~10s line carries heap/RSS, build/eviction/drain activity, the build
+queue depth, and a `counters` block. The counters that matter for regressions:
+
+- `counters.evictions` — LRU evictions of resident blueprint instances. **Non-zero
+  under a steady same-blueprint workload is the classic capacity-1 thrash signal**
+  (batch relogins colliding with api traffic → api↔auth oscillation).
+- `counters.connGuard` — connection-class errors **absorbed** by the guard
+  (57P01 / 08006 / ECONNRESET / …) during a PG crash-recovery window. Counting up
+  is healthy (the node survived); the alternative is a process death.
+- `counters.buildWaitTimeouts` — requests that hit `GRAPHILE_BUILD_TIMEOUT_MS` and
+  returned `503 BUILD_TIMEOUT` (the build still completes in the background). Rising
+  under load means the build queue is backing up.
+- `builds` / `drains` — schema build and drain totals.
+- `heapUsedMB` / `rssMB` / `buildQueueDepth` — sampled gauges; `summarize` surfaces
+  the `heapUsedMaxMB` / `rssMaxMB` / `buildQueueDepthMax` per ramp step.
+
+### `/metrics` endpoint (live snapshot)
+
+Set `GRAPHILE_METRICS_ENDPOINT=1` to expose the same snapshot as JSON at
+`GET /metrics`. It is **loopback-guarded** — only requests from `127.0.0.1` / `::1`
+are served (never reachable off-box), so it is safe to leave enabled on a soak.
+`run soak status` reads it for the live snapshot.
+
+### PG-side sampler line — `pg-<label>.jsonl`
+
+`measure pg` opens a **fresh** `pg` client per sample (a persistent idle client
+would be reaped by `idle_session_timeout`) and appends one line per `--interval-sec`
+(default 30). Sampling errors are recorded on the line and never kill the sampler —
+a PG crash/recovery window is exactly the data worth keeping. Fields:
+
+```
+t              ISO timestamp
+docker         { raw, usedBytes, limitBytes }   # `docker stats` for --container (default constructive-scale-pg); {err} on failure
+backendsByState{ active, idle, "idle in transaction", null, … }  # pg_stat_activity grouped by state
+backendsTotal  total backends on this database
+backendsAllDbs sum(numbackends) across all databases
+pgClassRows    count(*) FROM pg_class   # catalog-size proxy; drives the 21KB/37KB laws
+dbSizeBytes    pg_database_size(current_database())
+err            present only if the whole sample failed
+```
+
+### Collector summary — `measure collector`
+
+`measure collector` samples the server process RSS via `ps -o rss=` every
+`--interval-sec` (default 15) and tails `metrics-<label>.jsonl`. At exit
+(SIGINT/SIGTERM, `--duration-sec`, or the PID disappearing) it writes:
+
+```
+rss.minMb / maxMb / finalMb
+rss.slopeMbPerHour     least-squares slope over the LAST HALF of samples (the leak signal)
+rss.series[]           { tSec, rssMb }
+metrics.evictionsTotal / drainsTotal / buildsTotal   picked from the final metrics line
+metrics.linesSeen, metrics.lastLine
+stopReason, durationSec
+```
+
+The last-half slope is the headline longevity number: a flat/negative
+`slopeMbPerHour` over a multi-hour soak means no leak.
+
+### Workload report — `load harness`
+
+`load harness` streams a rolling progress JSONL line to stdout every `--report-sec`
+and writes the full report to `--out` (`harness-<label>.json`) on completion or
+`SIGTERM` (after a ≤ 15s drain). Each progress line:
+
+```
+t=progress, at, elapsedSec, windowSec,
+sent, completed, ok, err,
+windowRps, cumRps, windowErrRate, inFlight, dropped, rotating,
+latencyWindow { count, min, mean, p50, p95, p99, max },
+sentinelChecks, sentinelOwnSeen, sentinelOk
+```
+
+The **bleed sentinel** periodically (`--sentinel-interval-sec`, default 60) reads
+each tenant and asserts no foreign `CANARY-<dbname>` row is visible. A violation
+flips `sentinelOk=false`, records the offending rows, and **exits 2**. Exit codes:
+`0` ok · `1` fatal · `2` bleed-sentinel violation.
+
+### Merged report — `report merge`
+
+`report merge` aligns the server metrics JSONL, harness progress JSONL, churn /
+soak-ops event lines, and the pg-sampler JSONL into one `report-data.json`
+(a single aligned time series with event markers, the heap slope, and counter
+deltas) and prints a markdown summary table to stdout. `report summarize`
+one-lines each `run ramp` step (crash / errRate / rps / p50-p95-p99 / heapMax /
+evict / builds / connGuard / pgConnMax).
+
+---
+
+## Sizing model (capacity law + constants)
+
+Memory cost is driven by **catalog size** (total relations in the PG database),
+**not** by tenant count. Two constants, measured on the 61k-`pg_class`-row catalog:
+
+- **Node instance heap** `I ≈ 50MB + 21KB × pg_class_rows` — every *resident schema
+  instance* retains this, class-independent (it is the introspection graph), and it
+  is live memory, not GC-able. ~1.3GB at 61k rows.
+- **PG introspection spike** `≈ 37KB × pg_class_rows` **per build** — every schema
+  build spikes a Postgres backend by this much (~2.7GB at 61k rows; OOM > 5.4GB at
+  135k). Backends retain multi-GB relcache and accumulate across the pool; recycle
+  via `idle_session_timeout` or pgbouncer `server_lifetime`.
+
+Tenants that share a blueprint are **free** — zero marginal heap, zero marginal
+builds. So you size in two axes: how many relations live in one PG database (shard
+size) and how many distinct blueprint shapes a node keeps resident (node capacity
+`R`).
+
+**Node capacity** (`report predict`, via `graphile-cache.computeCapacityFromBudget`):
+
+```
+I = per-instance heap        (measure once per catalog size)
+B = base reserve             (server + request working set; default 256MB)
+T = build transient reserve  (one in-flight build;          default 768MB @ 61k rows)
+H = --max-old-space-size
+
+R = clamp( min( ⌊(H − B) / I⌋,  ⌊(H − B − T) / I⌋ + 1 ), 1, 50 )
+```
+
+Validated @61k rows: min viable heap **1536MB** (1 resident; 1152MB aborts
+mid-build with a V8 SIGABRT); 2048MB → R=1; 3584MB → R=2 (api + auth both resident,
+0 evictions). Container RSS ≈ heap × 1.4–1.5 (native/external on top of V8).
+
+**Operating rule:** `R` must cover the node's *actively hit* blueprint set — api and
+auth shapes count **separately**. A tenant fleet on one node needs `R ≥ 2`: at `R=1`
+hourly batch relogins collide with api traffic and failed relogins retry every 30s →
+self-sustaining eviction oscillation; at `R=2` the same workload runs clean.
+
+**Shard-per-PG-database.** Tenants-per-database is the fundamental unit, bounded by
+catalog size on both sides. Instance heap grows with the shard's catalog, so bigger
+shards need disproportionately bigger app nodes — favor **more, smaller shards**. The
+blueprint cache key already scopes by database, so shard-local pooling needs no code
+change. Concretely, ~1000 marketplace-class tenants ≈ 10 shards × ~100 tenants (16GB
+PG nodes), each served by one app node at `R=2` (heap ~6GB, container ~9GB).
+
+---
+
+## Environment knobs
+
+Server behavior is controlled by `GRAPHILE_*` env vars (the harness sets the ones it
+manages; set the rest to tune). Heap is controlled by Node.
+
+| Knob | Effect |
+|---|---|
+| `NODE_OPTIONS=--max-old-space-size=<mb>` | V8 heap budget `H` — the primary capacity lever |
+| `GRAPHILE_BLUEPRINT_POOLING` | `1` = one shared instance per schema-shape (the whole point) |
+| `GRAPHILE_DEBUG_METRICS` | `1` = write the metrics JSONL |
+| `GRAPHILE_DEBUG_METRICS_FILE` | metrics JSONL path |
+| `GRAPHILE_DEBUG_METRICS_INTERVAL_MS` | metrics sample period |
+| `GRAPHILE_METRICS_ENDPOINT` | `1` = expose `GET /metrics` (loopback-guarded) |
+| `GRAPHILE_CACHE_MAX` | hard cap on resident instances (heap-aware; floor 1) |
+| `GRAPHILE_CACHE_INSTANCE_HEAP_BYTES` | measured per-instance heap `I` (set to your catalog's delta + ~10%) |
+| `GRAPHILE_CACHE_BASE_RESERVE_BYTES` | base reserve `B` (default 256MB) |
+| `GRAPHILE_CACHE_BUILD_RESERVE_BYTES` | build transient reserve `T` (default 768MB @ 61k) |
+| `GRAPHILE_CACHE_TTL_MS` | idle resident-instance TTL before drain |
+| `GRAPHILE_CACHE_DRAIN_TIMEOUT_MS` | grace period to drain a to-be-evicted instance |
+| `GRAPHILE_MEMORY_GOVERNOR` | `1` = enable the heap-pressure governor |
+| `GRAPHILE_MEMORY_GOVERNOR_ELEVATED` | proactive-evict threshold (default ~85%) |
+| `GRAPHILE_MEMORY_GOVERNOR_CRITICAL` | refuse-builds threshold (default ~92%; 503 + Retry-After) |
+| `GRAPHILE_BUILD_CONCURRENCY` | BuildSemaphore size (default 1 — serializes node AND PG build spikes) |
+| `GRAPHILE_BUILD_TIMEOUT_MS` | request build-wait bound (503 `BUILD_TIMEOUT`; build finishes in background) |
+| `GRAPHILE_CONNECTION_GUARD` | `0` = disable the connection-class error guard (default on) |
+
+Rule of thumb without measuring: `GRAPHILE_CACHE_INSTANCE_HEAP_BYTES ≈ 50MB + 21KB ×
+pg_class_rows`; measure yours with `perf-harness measure instance-heap`.
+
+---
+
+## Hub safety
+
+`HUB_PORTS = [5432, 3000, 3001, 3002, 9000]` — the ports a local Constructive hub
+(Postgres, the two GraphQL servers, the dashboard, MinIO) listens on. **Every**
+command that dials Postgres or a server port refuses one of those ports unless you
+pass `--allow-hub`, so the harness can never point load at, or spawn a server on top
+of, a live hub. The Postgres port defaults to **5433, never 5432**. Only pass
+`--allow-hub` when you genuinely mean to target the hub.
+
+---
+
+## Credentials
+
+Never hardcoded, never interpolated into shell strings (children are spawned with
+argument arrays only):
+
+- `--email` defaults to `seeder@gmail.com`.
+- `--password` has **no default**. Resolution order: `--password` flag → `PERF_PASSWORD`
+  env. Commands that need auth error out with guidance when it is missing —
+  `export PERF_PASSWORD=…` is the intended path.
+
+---
+
+## Command reference
+
+```
+fleet discover   --like <pat> --out <file> [--pretty] [--pg-*]
+fleet provision  --count <n> --prefix <p> --blueprint <b> [--start-index] [--concurrency] [--validate]
+fleet drift      --groups <n> --per-group <n> --column-drift <n> [--pg-*]
+fleet canary     --fleet <file> [--table categories] [--cleanup] [--pg-*]
+fleet subset     --fleet <file> [--blueprints <n>] [--per-blueprint <n>] [--tenants <n>] [--same-bp-regex] --out <file>
+fleet teardown   --fleet <file> | --only <name> [--keep <n>] [--dry-run] [--pg-*]
+
+load harness     --fleet <file> --port <n> [--rps] [--shape zipf|uniform|burst] [--mix read:..,write:..,meta:..]
+                 [--auth 1] [--sentinel-interval-sec 60] [--relogin-sec 3600] [--duration-sec] --out <file>
+load churn       --fleet <file> [--interval-notify-sec 20] [--provision-every-sec] [--channel schema:update] [--duration-sec]
+
+measure collector    --pid <n> [--metrics-file <f>] [--interval-sec 15] [--duration-sec] --out <file>
+measure pg           [--container constructive-scale-pg] [--interval-sec 30] [--duration-sec] --out <file> [--pg-*]
+measure instance-heap --label <l> --host <api-host> [--port] [--heap-mb] [--cache-max 1] [--settle-sec]
+
+run ramp         --plan <plan.json> [--only step1,step2] --out <results.jsonl>
+run soak start   --fleet <file> --label <l> [--port] [--heap-mb] [--duration-sec] [--out-dir]
+run soak status  --label <l> [--out-dir]
+run soak stop    --label <l> [--out-dir]
+run soak-ops     [--interval-sec 7200] [--duration-sec 86400] [--prefix soak]
+
+report summarize <results.jsonl> [...more]
+report merge     --metrics <m.jsonl> --harness-log <h.jsonl> [--churn-log <c.jsonl>] [--ops-log <o.log>] [--pg <pg.jsonl>] [--out-dir ./perf-out]
+report predict   --instance-heap-bytes <n> [--heap-mb 1536,2048,3584] [--base-reserve-bytes <n>] [--build-reserve-bytes <n>]
+
+regression run       --fleet <file> [--suite quick|standard|deep] [--baseline <name>] [--port] [--heap-mb] [--deep-heap-mb 7168] [--out-dir] [--only <checks>] [--skip <checks>]
+regression baselines
+```
+
+Global: `--help` / `-h` (top-level or per-domain usage) · `--version`.
+Connection flags `--pg-host/--pg-port/--pg-user/--pg-password/--pg-database` override
+`PGHOST/PGPORT/PGUSER/PGPASSWORD/PGDATABASE`, which override
+`localhost/5433/postgres/password/constructive`.
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| `0` | ok / suite pass |
+| `1` | fatal error / suite fail / usage error |
+| `2` | cross-tenant **bleed** sentinel violation (`load harness`, `regression run`) |
+
+## Testing
+
+`pnpm test` (jest) is pure-unit and needs **no** network, Postgres, or Docker:
+argv parsing + coercions, the hub guardrail, RNG determinism, the zipf/mix samplers,
+histogram percentiles, subset construction, collector math, token-field scoring,
+ramp config merge, summarize/merge on fixtures, the baseline comparator, the deep-suite
+helpers (host-rewrite fleet derivation, partition-creep math, advisory-verdict
+aggregation, and the settings-SQL builder), and the tenant-factory shape fingerprint.
+Anything needing a live server/PG is gated behind `PERF_E2E=1`.
diff --git a/packages/perf-harness/jest.config.js b/packages/perf-harness/jest.config.js
new file mode 100644
index 0000000000..057a9420ed
--- /dev/null
+++ b/packages/perf-harness/jest.config.js
@@ -0,0 +1,18 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        babelConfig: false,
+        tsconfig: 'tsconfig.json',
+      },
+    ],
+  },
+  transformIgnorePatterns: [`/node_modules/*`],
+  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  modulePathIgnorePatterns: ['dist/*']
+};
diff --git a/packages/perf-harness/package.json b/packages/perf-harness/package.json
new file mode 100644
index 0000000000..d91bc4f2d1
--- /dev/null
+++ b/packages/perf-harness/package.json
@@ -0,0 +1,58 @@
+{
+  "name": "@constructive-io/perf-harness",
+  "version": "0.1.0",
+  "author": "Constructive <developers@constructive.io>",
+  "description": "Reusable performance / regression harness for the Constructive GraphQL server",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "bin": {
+    "perf-harness": "index.js",
+    "cperf": "index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "dev": "ts-node ./src/index.ts",
+    "lint": "eslint . --fix",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@inquirerer/utils": "^3.3.9",
+    "graphile-cache": "workspace:^",
+    "inquirerer": "^4.9.1",
+    "pg": "^8.21.0"
+  },
+  "devDependencies": {
+    "@inquirerer/test": "^1.4.3",
+    "@types/node": "^22.19.11",
+    "@types/pg": "^8.20.0",
+    "makage": "^0.3.0",
+    "ts-node": "^10.9.2"
+  },
+  "keywords": [
+    "performance",
+    "regression",
+    "harness",
+    "soak",
+    "constructive",
+    "graphile",
+    "postgres"
+  ]
+}
diff --git a/packages/perf-harness/src/commands/fleet.ts b/packages/perf-harness/src/commands/fleet.ts
new file mode 100644
index 0000000000..07715f5467
--- /dev/null
+++ b/packages/perf-harness/src/commands/fleet.ts
@@ -0,0 +1,120 @@
+/**
+ * `fleet` command group — provision / discover / drift / canary / subset /
+ * teardown the perf tenant fleet.
+ *
+ * Each subcommand delegates to a `src/fleet/*` module, except `subset`, whose
+ * pure algorithm lives in `core/fleetfile.buildSubset`; the CLI glue (read
+ * --fleet + --drifted, write --out) is implemented inline here.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv, asBool, asInt, usageExit } from '../core/args';
+import { buildSubset, loadFleet, SubsetOpts } from '../core/fleetfile';
+import * as canary from '../fleet/canary';
+import * as discover from '../fleet/discover';
+import * as drift from '../fleet/drift';
+import * as provision from '../fleet/provision';
+import * as teardown from '../fleet/teardown';
+
+export const domain = 'fleet';
+export const summary = 'discover / provision / drift / canary / subset / teardown the perf tenant fleet';
+
+export interface Subcommand {
+  usage: string;
+  run(argv: Argv): Promise<number>;
+}
+
+const SUBSET_USAGE = `perf-harness fleet subset — derive a ramp-specific fleet manifest from a fleet + drift assignment
+
+Options:
+  --fleet <file>         fleet manifest from \`fleet discover\` (required)
+  --drifted <file>       drift assignment from \`fleet drift\` (optional)
+  --out <file>           write the subset manifest here (required)
+  --blueprints <K>       diversity subset: first K blueprint groups
+  --per-blueprint <N>    tenants per blueprint group (default: 5)
+  --tenants <N>          tenant-count subset: N group-0 tenants (single blueprint)
+  --same-bp-regex <re>   group-0 membership regex (default: ^(factory[0-9]+|marketplace_db_tenant1)$)
+  --help
+`;
+
+async function runSubset(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) return usageExit(SUBSET_USAGE, 0);
+
+  const fleetFile = typeof argv.fleet === 'string' ? argv.fleet : null;
+  const out = typeof argv.out === 'string' ? argv.out : null;
+  if (!fleetFile) {
+    console.error('--fleet is required');
+    return 1;
+  }
+  if (!out) {
+    console.error('--out is required');
+    return 1;
+  }
+
+  try {
+    const fleet = loadFleet(fleetFile).tenants;
+    const drifted =
+      typeof argv.drifted === 'string'
+        ? JSON.parse(fs.readFileSync(argv.drifted, 'utf8'))
+        : { groups: {}, columnDrift: [] };
+    const o: SubsetOpts = {
+      blueprints: asInt(argv.blueprints, 0),
+      perBlueprint: asInt(argv['per-blueprint'], 5),
+      tenants: asInt(argv.tenants, 0),
+      sameBpRegex: typeof argv['same-bp-regex'] === 'string' ? argv['same-bp-regex'] : undefined
+    };
+
+    const { subset, tenants, warnings } = buildSubset(fleet, drifted, o);
+    for (const w of warnings) console.error(w);
+
+    // Preserve the original subset-fleet.mjs manifest shape (adds `derivedFrom`,
+    // which core/fleetfile.buildSubset omits).
+    const manifest = {
+      generatedAt: subset.generatedAt,
+      derivedFrom: fleetFile,
+      subset: subset.subset,
+      count: subset.count,
+      tenants: subset.tenants
+    };
+
+    fs.mkdirSync(path.dirname(path.resolve(out)), { recursive: true });
+    fs.writeFileSync(out, JSON.stringify(manifest) + '\n');
+    console.error(`[subset] ${subset.subset}: ${tenants.length} tenants -> ${out}`);
+    return 0;
+  } catch (err: any) {
+    console.error(String((err && err.message) || err));
+    return 1;
+  }
+}
+
+// Concise one-line synopses for the composed domain-level help listing; each
+// subcommand's own `--help` prints its fuller USAGE (via its `run`).
+export const subcommands: Record<string, Subcommand> = {
+  discover: {
+    usage: "fleet discover [--like '%'] [--out fleet.json] [--pretty] [--pg-* ...]",
+    run: discover.run
+  },
+  provision: {
+    usage:
+      'fleet provision [--count 1] [--prefix factory] [--blueprint marketplace] [--concurrency 1] [--dry-run] [--validate <db>] [--pg-* ...]',
+    run: provision.run
+  },
+  drift: {
+    usage: 'fleet drift [--groups K] [--per-group 4] [--column-drift N] [--out <f>] [--pg-* ...]',
+    run: drift.run
+  },
+  canary: {
+    usage: 'fleet canary --fleet <file> [--table categories] [--cleanup] [--pg-* ...]',
+    run: canary.run
+  },
+  subset: {
+    usage:
+      'fleet subset --fleet <file> --out <file> [--drifted <file>] [--blueprints K --per-blueprint N | --tenants N] [--same-bp-regex <re>]',
+    run: runSubset
+  },
+  teardown: {
+    usage: 'fleet teardown [--prefix factory] [--keep 40] [--only <db>] [--dry-run] [--pg-* ...]',
+    run: teardown.run
+  }
+};
diff --git a/packages/perf-harness/src/commands/load.ts b/packages/perf-harness/src/commands/load.ts
new file mode 100644
index 0000000000..586abcf61d
--- /dev/null
+++ b/packages/perf-harness/src/commands/load.ts
@@ -0,0 +1,31 @@
+/**
+ * `load` domain — workload drivers.
+ *
+ *   perf-harness load harness  paced GraphQL load + bleed sentinel (harness.mjs)
+ *   perf-harness load churn    schema-cache NOTIFY churn        (churn-driver.mjs)
+ *
+ * Each subcommand handles its own `--help` and returns a numeric exit code
+ * (harness: 0 ok / 1 fatal / 2 bleed-sentinel violation; churn: 0 / 1).
+ */
+import { Argv } from '../core/args';
+import { runChurn } from '../load/churn';
+import { runHarness } from '../load/harness';
+
+export const domain = 'load';
+export const summary = 'workload drivers — paced GraphQL load (bleed sentinel) and schema-cache churn';
+
+export interface Subcommand {
+  usage: string;
+  run(argv: Argv): Promise<number>;
+}
+
+export const subcommands: Record<string, Subcommand> = {
+  harness: {
+    usage: 'load harness --fleet <file> [--port 3333 --duration-sec 60 --rps 20 --mix read:.7,write:.25,meta:.05 --shape zipf|uniform|burst --auth 0|1 --out results.json]',
+    run: runHarness
+  },
+  churn: {
+    usage: 'load churn --fleet <file> [--interval-notify-sec 20 --provision-every-sec 0 --duration-sec 3600 --channel schema:update --pg-* ...]',
+    run: runChurn
+  }
+};
diff --git a/packages/perf-harness/src/commands/measure.ts b/packages/perf-harness/src/commands/measure.ts
new file mode 100644
index 0000000000..b3fee471f8
--- /dev/null
+++ b/packages/perf-harness/src/commands/measure.ts
@@ -0,0 +1,34 @@
+/**
+ * `measure` domain — memory/heap measurement primitives.
+ *
+ *   measure collector      RSS sampler + server-metrics tailer (collector.mjs)
+ *   measure pg             PG-side docker + pg_stat_activity sampler (pg-sampler.mjs)
+ *   measure instance-heap  marginal per-class instance heap cost (measure-instance-heap.mjs)
+ */
+import { Argv } from '../core/args';
+import { runCollector } from '../measure/collector';
+import { runInstanceHeap } from '../measure/instanceHeap';
+import { runPgSampler } from '../measure/pgSampler';
+
+export const domain = 'measure';
+export const summary = 'memory/heap measurement: RSS+metrics collector, PG sampler, per-class instance-heap';
+
+export interface Subcommand {
+  usage: string;
+  run(argv: Argv): Promise<number>;
+}
+
+export const subcommands: Record<string, Subcommand> = {
+  collector: {
+    usage: 'measure collector --pid <n> [--metrics-file <f>] [--interval-sec 15] [--duration-sec 0] [--out collector.json]',
+    run: runCollector
+  },
+  pg: {
+    usage: 'measure pg [--out out/pg-soak.jsonl] [--interval-sec 30] [--duration-sec 0] [--container constructive-scale-pg] [--pg-* ...]',
+    run: runPgSampler
+  },
+  'instance-heap': {
+    usage: 'measure instance-heap --host <vhost> [--label <name>] [--port 3344] [--heap-mb 2048] [--cache-max 1] [--settle-sec 70] [--out-dir ./perf-out]',
+    run: runInstanceHeap
+  }
+};
diff --git a/packages/perf-harness/src/commands/regression.ts b/packages/perf-harness/src/commands/regression.ts
new file mode 100644
index 0000000000..8e7b8b1cab
--- /dev/null
+++ b/packages/perf-harness/src/commands/regression.ts
@@ -0,0 +1,44 @@
+/**
+ * `perf-harness regression <sub>` — the one-command regression suite + catalog.
+ *
+ * Registration contract (consumed by src/index.ts): a domain name, a one-line
+ * summary, a `Subcommand` shape, and a `subcommands` map.
+ */
+import { Argv } from '../core/args';
+import { DEFAULT_BASELINE, listBaselines } from '../regression/baselines';
+import { runRegression } from '../regression/suite';
+
+export const domain = 'regression';
+export const summary = 'run the regression suite against a baseline, or list known baselines';
+
+export interface Subcommand {
+  usage: string;
+  run(argv: Argv): Promise<number>;
+}
+
+async function runBaselines(_argv: Argv): Promise<number> {
+  const rows = listBaselines();
+  console.log(`known baselines (default: ${DEFAULT_BASELINE}):`);
+  for (const b of rows) {
+    console.log(
+      `  ${b.name}  (captured ${b.capturedAt})  catalog=${b.catalogPgClassRows} rows  ` +
+        `I=${b.instanceHeapKBPerRow}KB/row  minViable=${b.minViableHeapMB}MB  ` +
+        `thresholds: errRate<=${b.thresholds.maxHealthyErrRate} p99<=${b.thresholds.maxHealthyP99Ms}ms ` +
+        `zmDelta<=${b.thresholds.maxZeroMarginalDeltaMB}MB heapKB/row<=${b.thresholds.maxInstanceHeapKBPerRow} ` +
+        `slope<=${b.thresholds.maxHeapSlopeMBPerHour}MB/h`
+    );
+  }
+  return 0;
+}
+
+export const subcommands: Record<string, Subcommand> = {
+  run: {
+    usage:
+      'regression run --fleet <manifest> [--suite quick|standard|deep] [--baseline <name>] [--port 3345] [--heap-mb 3584] [--deep-heap-mb 7168] [--out-dir ./perf-out] [--drifted <f>] [--same-bp-regex <re>] [--only <scenario,...>] [--skip <scenario,...>] [--server-cmd "..."] [--allow-hub]',
+    run: runRegression
+  },
+  baselines: {
+    usage: 'regression baselines',
+    run: runBaselines
+  }
+};
diff --git a/packages/perf-harness/src/commands/report.ts b/packages/perf-harness/src/commands/report.ts
new file mode 100644
index 0000000000..a49843cd77
--- /dev/null
+++ b/packages/perf-harness/src/commands/report.ts
@@ -0,0 +1,34 @@
+/**
+ * `perf-harness report <sub>` — post-run analysis commands.
+ *
+ * Registration contract (consumed by src/index.ts): a domain name, a one-line
+ * summary, a `Subcommand` shape, and a `subcommands` map.
+ */
+import { Argv } from '../core/args';
+import { runMerge } from '../report/merge';
+import { runPredict } from '../report/predict';
+import { runSummarize } from '../report/summarize';
+
+export const domain = 'report';
+export const summary = 'analyze run artifacts: summarize step results, merge series, predict capacity';
+
+export interface Subcommand {
+  usage: string;
+  run(argv: Argv): Promise<number>;
+}
+
+export const subcommands: Record<string, Subcommand> = {
+  summarize: {
+    usage: 'report summarize <results.jsonl> [more.jsonl ...]',
+    run: runSummarize
+  },
+  merge: {
+    usage:
+      'report merge --metrics <m.jsonl> --harness-log <h.jsonl> [--churn-log <c.jsonl>] [--ops-log <o.log>] [--pg <pg.jsonl>] [--out-dir ./perf-out]',
+    run: runMerge
+  },
+  predict: {
+    usage: 'report predict --instance-heap-bytes <n> [--heap-mb 1536,2048,3584] [--base-reserve-bytes <n>] [--build-reserve-bytes <n>]',
+    run: runPredict
+  }
+};
diff --git a/packages/perf-harness/src/commands/run.ts b/packages/perf-harness/src/commands/run.ts
new file mode 100644
index 0000000000..49b8305a1d
--- /dev/null
+++ b/packages/perf-harness/src/commands/run.ts
@@ -0,0 +1,28 @@
+/**
+ * `run` domain — server lifecycle + ramp / soak orchestration.
+ *
+ * Subcommands:
+ *   run ramp                     V2 limits-discovery executor (fresh server per step)
+ *   run soak <start|status|stop> long-running soak orchestrator
+ *   run soak-ops                 provision/drop cycles during a soak
+ *
+ * `run soak` routes on the next positional (argv._[2]) inside runSoak.
+ */
+import { Argv } from '../core/args';
+import { RAMP_USAGE, runRamp } from '../run/ramp';
+import { runSoak, SOAK_USAGE } from '../run/soak';
+import { runSoakOps, SOAK_OPS_USAGE } from '../run/soakOps';
+
+export const domain = 'run';
+export const summary = 'server lifecycle + ramp / soak orchestration';
+
+export interface Subcommand {
+  usage: string;
+  run(argv: Argv): Promise<number>;
+}
+
+export const subcommands: Record<string, Subcommand> = {
+  ramp: { usage: RAMP_USAGE, run: (argv: Argv) => runRamp(argv) },
+  soak: { usage: SOAK_USAGE, run: (argv: Argv) => runSoak(argv) },
+  'soak-ops': { usage: SOAK_OPS_USAGE, run: (argv: Argv) => runSoakOps(argv) }
+};
diff --git a/packages/perf-harness/src/core/__tests__/args.test.ts b/packages/perf-harness/src/core/__tests__/args.test.ts
new file mode 100644
index 0000000000..5e9bece78b
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/args.test.ts
@@ -0,0 +1,65 @@
+import { asBool, asFloat, asInt, parseArgv } from '../args';
+
+describe('parseArgv', () => {
+  test('--flag value form', () => {
+    expect(parseArgv(['--host', 'h'])).toEqual({ _: [], host: 'h' });
+  });
+
+  test('--flag=value form', () => {
+    expect(parseArgv(['--host=h'])).toEqual({ _: [], host: 'h' });
+  });
+
+  test('bare --flag becomes true', () => {
+    expect(parseArgv(['--verbose'])).toEqual({ _: [], verbose: true });
+  });
+
+  test('bare flag immediately before another flag is true', () => {
+    const a = parseArgv(['--dry-run', '--tenants', '5']);
+    expect(a['dry-run']).toBe(true);
+    expect(a.tenants).toBe('5');
+  });
+
+  test('trailing bare flag is true', () => {
+    const a = parseArgv(['--tenants', '5', '--allow-hub']);
+    expect(a.tenants).toBe('5');
+    expect(a['allow-hub']).toBe(true);
+  });
+
+  test('positionals collect into _', () => {
+    const a = parseArgv(['fleet', 'subset', '--tenants', '5']);
+    expect(a._).toEqual(['fleet', 'subset']);
+    expect(a.tenants).toBe('5');
+  });
+
+  test('empty argv yields just _', () => {
+    expect(parseArgv([])).toEqual({ _: [] });
+  });
+});
+
+describe('coercions', () => {
+  test('asBool truthy tokens', () => {
+    for (const v of ['1', 'true', 'TRUE', 'yes', 'on']) expect(asBool(v)).toBe(true);
+  });
+
+  test('asBool falsy tokens + default', () => {
+    for (const v of ['0', 'false', 'no', 'nope', 'off']) expect(asBool(v)).toBe(false);
+    expect(asBool(undefined)).toBe(false);
+    expect(asBool(undefined, true)).toBe(true);
+    expect(asBool(null, true)).toBe(true);
+    expect(asBool(true)).toBe(true);
+    expect(asBool(false)).toBe(false);
+  });
+
+  test('asInt parses / falls back', () => {
+    expect(asInt('42')).toBe(42);
+    expect(asInt('42px')).toBe(42);
+    expect(asInt(undefined, 7)).toBe(7);
+    expect(asInt('notnum', 3)).toBe(3);
+  });
+
+  test('asFloat parses / falls back', () => {
+    expect(asFloat('3.14')).toBeCloseTo(3.14);
+    expect(asFloat(undefined, 1.5)).toBe(1.5);
+    expect(asFloat('nope', 2.5)).toBe(2.5);
+  });
+});
diff --git a/packages/perf-harness/src/core/__tests__/config.test.ts b/packages/perf-harness/src/core/__tests__/config.test.ts
new file mode 100644
index 0000000000..317059e6bc
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/config.test.ts
@@ -0,0 +1,83 @@
+import { parseArgv } from '../args';
+import { assertPortAllowed, HUB_PORTS, pgConfigFromArgv, resolveCreds } from '../config';
+
+const ORIGINAL_ENV = process.env;
+beforeEach(() => {
+  process.env = { ...ORIGINAL_ENV };
+});
+afterEach(() => {
+  process.env = ORIGINAL_ENV;
+});
+
+describe('hub guardrail', () => {
+  test('HUB_PORTS is the exact reserved set', () => {
+    expect(HUB_PORTS).toEqual([5432, 3000, 3001, 3002, 9000]);
+  });
+
+  test('reserved hub port 5432 throws and names --allow-hub', () => {
+    expect(() => assertPortAllowed(5432, false)).toThrow(/--allow-hub/);
+  });
+
+  test('every reserved port throws', () => {
+    for (const p of HUB_PORTS) expect(() => assertPortAllowed(p, false)).toThrow();
+  });
+
+  test('isolated port 5433 passes', () => {
+    expect(() => assertPortAllowed(5433, false)).not.toThrow();
+  });
+
+  test('--allow-hub overrides the guardrail', () => {
+    expect(() => assertPortAllowed(5432, true)).not.toThrow();
+  });
+});
+
+describe('pgConfigFromArgv precedence', () => {
+  test('defaults to 5433 (never 5432) / localhost / postgres / constructive', () => {
+    for (const k of ['PGHOST', 'PGPORT', 'PGUSER', 'PGPASSWORD', 'PGDATABASE']) delete process.env[k];
+    const cfg = pgConfigFromArgv(parseArgv([]));
+    expect(cfg).toEqual({
+      host: 'localhost',
+      port: 5433,
+      user: 'postgres',
+      password: 'password',
+      database: 'constructive'
+    });
+  });
+
+  test('flags beat env beat defaults', () => {
+    process.env.PGHOST = 'envhost';
+    process.env.PGPORT = '5999';
+    process.env.PGUSER = 'envuser';
+    const cfg = pgConfigFromArgv(parseArgv(['--pg-host', 'flaghost', '--pg-database', 'mydb']));
+    expect(cfg.host).toBe('flaghost'); // flag wins
+    expect(cfg.port).toBe(5999); // env beats default
+    expect(cfg.user).toBe('envuser'); // env beats default
+    expect(cfg.database).toBe('mydb'); // flag
+    expect(cfg.password).toBe('password'); // default
+  });
+
+  test('rejects hub port 5432 unless --allow-hub', () => {
+    expect(() => pgConfigFromArgv(parseArgv(['--pg-port', '5432']))).toThrow(/--allow-hub/);
+    const cfg = pgConfigFromArgv(parseArgv(['--pg-port', '5432', '--allow-hub']));
+    expect(cfg.port).toBe(5432);
+  });
+});
+
+describe('resolveCreds', () => {
+  test('email defaults to seeder@gmail.com; password never has a literal default', () => {
+    delete process.env.PERF_PASSWORD;
+    expect(resolveCreds(parseArgv([]))).toEqual({ email: 'seeder@gmail.com', password: null });
+  });
+
+  test('password resolution: flag > PERF_PASSWORD env > null', () => {
+    delete process.env.PERF_PASSWORD;
+    expect(resolveCreds(parseArgv(['--password', 'p1'])).password).toBe('p1');
+    process.env.PERF_PASSWORD = 'envpw';
+    expect(resolveCreds(parseArgv([])).password).toBe('envpw');
+    expect(resolveCreds(parseArgv(['--password', 'flagpw'])).password).toBe('flagpw');
+  });
+
+  test('custom email flag is honored', () => {
+    expect(resolveCreds(parseArgv(['--email', 'x@y.com'])).email).toBe('x@y.com');
+  });
+});
diff --git a/packages/perf-harness/src/core/__tests__/fixtures/drifted.json b/packages/perf-harness/src/core/__tests__/fixtures/drifted.json
new file mode 100644
index 0000000000..3503f9827a
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/fixtures/drifted.json
@@ -0,0 +1,6 @@
+{
+  "groups": {
+    "1": ["drift_a", "drift_b"]
+  },
+  "columnDrift": ["factory3"]
+}
diff --git a/packages/perf-harness/src/core/__tests__/fixtures/empty-fleet.json b/packages/perf-harness/src/core/__tests__/fixtures/empty-fleet.json
new file mode 100644
index 0000000000..c567a93b2b
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/fixtures/empty-fleet.json
@@ -0,0 +1 @@
+{ "tenants": [] }
diff --git a/packages/perf-harness/src/core/__tests__/fixtures/fleet.json b/packages/perf-harness/src/core/__tests__/fixtures/fleet.json
new file mode 100644
index 0000000000..2fa921f90b
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/fixtures/fleet.json
@@ -0,0 +1,13 @@
+{
+  "tenants": [
+    { "dbname": "factory1" },
+    { "dbname": "factory2" },
+    { "dbname": "factory3" },
+    { "dbname": "factory4" },
+    { "dbname": "factory5" },
+    { "dbname": "marketplace_db_tenant1" },
+    { "dbname": "tenant2" },
+    { "dbname": "drift_a" },
+    { "dbname": "drift_b" }
+  ]
+}
diff --git a/packages/perf-harness/src/core/__tests__/fleetfile.test.ts b/packages/perf-harness/src/core/__tests__/fleetfile.test.ts
new file mode 100644
index 0000000000..e9e4456af2
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/fleetfile.test.ts
@@ -0,0 +1,84 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { buildSubset, canaryName, CANARY_PREFIX, loadFleet, Tenant } from '../fleetfile';
+
+const fixture = (name: string): string => path.join(__dirname, 'fixtures', name);
+const fleet: Tenant[] = loadFleet(fixture('fleet.json')).tenants;
+const drifted = JSON.parse(fs.readFileSync(fixture('drifted.json'), 'utf8'));
+const names = (ts: Tenant[]): string[] => ts.map((t) => t.dbname);
+
+describe('loadFleet', () => {
+  test('reads the tenant array from a {tenants} manifest', () => {
+    const { tenants } = loadFleet(fixture('fleet.json'));
+    expect(tenants.length).toBe(9);
+  });
+
+  test('throws on an empty fleet', () => {
+    expect(() => loadFleet(fixture('empty-fleet.json'))).toThrow(/no tenants/);
+  });
+});
+
+describe('canary naming', () => {
+  test('prefix + dbname', () => {
+    expect(CANARY_PREFIX).toBe('CANARY-');
+    expect(canaryName({ dbname: 'factory7' })).toBe('CANARY-factory7');
+  });
+});
+
+describe('buildSubset — diversity mode', () => {
+  test('first K groups, N per group', () => {
+    const { subset, tenants, warnings } = buildSubset(fleet, drifted, { blueprints: 2, perBlueprint: 2 });
+    expect(names(tenants)).toEqual(['factory1', 'factory2', 'drift_a', 'drift_b']);
+    expect(subset.count).toBe(4);
+    expect(subset.subset).toBe('diversity k=2 per=2');
+    expect(warnings).toEqual([]);
+  });
+
+  test('warns when a group has fewer than perBlueprint tenants', () => {
+    const { tenants, warnings } = buildSubset(fleet, drifted, { blueprints: 2, perBlueprint: 5 });
+    // group0 gives 5 (factory1..5); drift group only has 2
+    expect(names(tenants)).toEqual(['factory1', 'factory2', 'factory3', 'factory4', 'factory5', 'drift_a', 'drift_b']);
+    expect(warnings).toEqual(['warn: group 1 has only 2/5 tenants']);
+  });
+
+  test('throws when asking for more blueprint groups than exist', () => {
+    expect(() => buildSubset(fleet, drifted, { blueprints: 5 })).toThrow('only 2 blueprint groups available, asked for 5');
+  });
+});
+
+describe('buildSubset — tenant-count mode', () => {
+  test('N group-0 tenants (column-drift tenant stays in group 0)', () => {
+    const { subset, tenants, warnings } = buildSubset(fleet, drifted, { tenants: 3 });
+    // factory3 is in columnDrift but keeps its relname set => still group 0
+    expect(names(tenants)).toEqual(['factory1', 'factory2', 'factory3']);
+    expect(subset.subset).toBe('tenant-count n=3 (single blueprint)');
+    expect(subset.count).toBe(3);
+    expect(warnings).toEqual([]);
+  });
+
+  test('warns when fewer undrifted tenants are available than requested', () => {
+    const { subset, tenants, warnings } = buildSubset(fleet, drifted, { tenants: 100 });
+    expect(tenants.length).toBe(6); // factory1..5 + marketplace_db_tenant1
+    expect(subset.subset).toBe('tenant-count n=6 (single blueprint)');
+    expect(warnings).toEqual(['warn: only 6/100 undrifted tenants available']);
+  });
+
+  test('excludes non-matching (divergent) seeder tenants like tenant2', () => {
+    const { tenants } = buildSubset(fleet, drifted, { tenants: 100 });
+    expect(names(tenants)).not.toContain('tenant2');
+    expect(names(tenants)).not.toContain('drift_a');
+  });
+});
+
+describe('buildSubset — mode selection', () => {
+  test('throws when neither mode is selected', () => {
+    expect(() => buildSubset(fleet, drifted, {})).toThrow('one of --blueprints or --tenants is required');
+  });
+
+  test('custom sameBpRegex changes group 0 membership', () => {
+    const { tenants } = buildSubset(fleet, { groups: {} }, { tenants: 100, sameBpRegex: '^factory[0-9]+$' });
+    // marketplace_db_tenant1 no longer matches
+    expect(names(tenants)).toEqual(['factory1', 'factory2', 'factory3', 'factory4', 'factory5']);
+  });
+});
diff --git a/packages/perf-harness/src/core/__tests__/histogram.test.ts b/packages/perf-harness/src/core/__tests__/histogram.test.ts
new file mode 100644
index 0000000000..b9593091b7
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/histogram.test.ts
@@ -0,0 +1,55 @@
+import { DEFAULT_BUCKETS, Histogram } from '../histogram';
+
+describe('Histogram', () => {
+  test('empty histogram: zero percentiles and summary', () => {
+    const h = new Histogram();
+    expect(h.percentile(50)).toBe(0);
+    expect(h.summary()).toEqual({
+      count: 0,
+      min: 0,
+      mean: 0,
+      p50: 0,
+      p95: 0,
+      p99: 0,
+      max: 0
+    });
+  });
+
+  test('summary has the exact field set and basic stats', () => {
+    const h = new Histogram();
+    [10, 20, 30].forEach((v) => h.record(v));
+    const s = h.summary();
+    expect(Object.keys(s).sort()).toEqual(['count', 'max', 'mean', 'min', 'p50', 'p95', 'p99'].sort());
+    expect(s.count).toBe(3);
+    expect(s.min).toBe(10);
+    expect(s.max).toBe(30);
+    expect(s.mean).toBe(20);
+  });
+
+  test('percentiles land on bucket boundaries', () => {
+    const h = new Histogram();
+    for (let i = 0; i < 100; i++) h.record(5); // 5 is a bucket edge
+    expect(h.percentile(50)).toBe(5);
+    expect(h.percentile(95)).toBe(5);
+    expect(h.percentile(99)).toBe(5);
+  });
+
+  test('values beyond the top bucket fall into the overflow bucket (rounded max)', () => {
+    const h = new Histogram();
+    h.record(100000); // > 60000, the last configured bucket
+    expect(h.percentile(99)).toBe(100000);
+    expect(h.summary().max).toBe(100000);
+  });
+
+  test('mean is rounded to 2 decimals', () => {
+    const h = new Histogram();
+    [1, 2, 2].forEach((v) => h.record(v)); // 5/3 = 1.666...
+    expect(h.summary().mean).toBe(1.67);
+  });
+
+  test('DEFAULT_BUCKETS is the fibonacci-ish ladder up to 60000', () => {
+    expect(DEFAULT_BUCKETS[0]).toBe(1);
+    expect(DEFAULT_BUCKETS[DEFAULT_BUCKETS.length - 1]).toBe(60000);
+    expect(DEFAULT_BUCKETS.length).toBe(23);
+  });
+});
diff --git a/packages/perf-harness/src/core/__tests__/proc.test.ts b/packages/perf-harness/src/core/__tests__/proc.test.ts
new file mode 100644
index 0000000000..dfab2f2b22
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/proc.test.ts
@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { isAlive, readJsonl, readPid, writeDone } from '../proc';
+
+const tmp = (): string => fs.mkdtempSync(path.join(os.tmpdir(), 'perf-proc-'));
+
+describe('readJsonl', () => {
+  test('parses valid lines and skips blank / corrupt ones', () => {
+    const dir = tmp();
+    const file = path.join(dir, 'metrics.jsonl');
+    fs.writeFileSync(
+      file,
+      [
+        JSON.stringify({ a: 1 }),
+        '', // blank
+        '   ', // whitespace only
+        '{ this is not json', // corrupt (e.g. half-flushed final row)
+        JSON.stringify({ b: 2 }),
+        '{"c":3}' // trailing line without newline
+      ].join('\n')
+    );
+    expect(readJsonl(file)).toEqual([{ a: 1 }, { b: 2 }, { c: 3 }]);
+  });
+
+  test('missing file returns []', () => {
+    expect(readJsonl(path.join(tmp(), 'does-not-exist.jsonl'))).toEqual([]);
+  });
+
+  test('empty file returns []', () => {
+    const dir = tmp();
+    const file = path.join(dir, 'empty.jsonl');
+    fs.writeFileSync(file, '');
+    expect(readJsonl(file)).toEqual([]);
+  });
+});
+
+describe('readPid', () => {
+  test('reads a written pid file', () => {
+    const dir = tmp();
+    fs.writeFileSync(path.join(dir, 'server.pid'), '12345\n');
+    expect(readPid(dir, 'server')).toBe(12345);
+  });
+
+  test('returns null when the pid file is absent', () => {
+    expect(readPid(tmp(), 'missing')).toBeNull();
+  });
+
+  test('returns null on garbage content', () => {
+    const dir = tmp();
+    fs.writeFileSync(path.join(dir, 'bad.pid'), 'not-a-pid\n');
+    expect(readPid(dir, 'bad')).toBeNull();
+  });
+});
+
+describe('isAlive', () => {
+  test('the current process is alive', () => {
+    expect(isAlive(process.pid)).toBe(true);
+  });
+
+  test('a pid above the max range is not alive', () => {
+    expect(isAlive(2 ** 30)).toBe(false);
+  });
+
+  test('non-positive pids are not alive', () => {
+    expect(isAlive(0)).toBe(false);
+    expect(isAlive(-1)).toBe(false);
+  });
+});
+
+describe('writeDone', () => {
+  test('writes a .done marker with default timestamp content', () => {
+    const dir = tmp();
+    writeDone(dir, 'soak');
+    const body = fs.readFileSync(path.join(dir, 'soak.done'), 'utf8');
+    expect(body.endsWith('\n')).toBe(true);
+    expect(body.trim().length).toBeGreaterThan(0);
+  });
+
+  test('writes explicit content (newline-terminated)', () => {
+    const dir = tmp();
+    writeDone(dir, 'soak', 'ok');
+    expect(fs.readFileSync(path.join(dir, 'soak.done'), 'utf8')).toBe('ok\n');
+  });
+});
diff --git a/packages/perf-harness/src/core/__tests__/rng.test.ts b/packages/perf-harness/src/core/__tests__/rng.test.ts
new file mode 100644
index 0000000000..64d7122249
--- /dev/null
+++ b/packages/perf-harness/src/core/__tests__/rng.test.ts
@@ -0,0 +1,88 @@
+import { makeMixSampler, makeRng, makeZipfSampler } from '../rng';
+
+describe('makeRng (mulberry32)', () => {
+  // Golden values guard the exact algorithm — a change here means the sampler
+  // sequences are no longer reproducible across harness versions.
+  test('seed 42 produces the known sequence', () => {
+    const r = makeRng(42);
+    expect([r(), r(), r()]).toEqual([
+      0.6011037519201636,
+      0.44829055899754167,
+      0.8524657934904099
+    ]);
+  });
+
+  test('seed 1 produces the known sequence', () => {
+    const r = makeRng(1);
+    expect([r(), r(), r()]).toEqual([
+      0.6270739405881613,
+      0.002735721180215478,
+      0.5274470399599522
+    ]);
+  });
+
+  test('same seed is deterministic; different seeds diverge', () => {
+    const a = makeRng(123);
+    const b = makeRng(123);
+    const c = makeRng(124);
+    const seqA = Array.from({ length: 20 }, () => a());
+    const seqB = Array.from({ length: 20 }, () => b());
+    const seqC = Array.from({ length: 20 }, () => c());
+    expect(seqA).toEqual(seqB);
+    expect(seqA).not.toEqual(seqC);
+  });
+
+  test('all outputs are in [0, 1)', () => {
+    const r = makeRng(9999);
+    for (let i = 0; i < 1000; i++) {
+      const v = r();
+      expect(v).toBeGreaterThanOrEqual(0);
+      expect(v).toBeLessThan(1);
+    }
+  });
+});
+
+describe('makeZipfSampler', () => {
+  test('favours low indices (monotonically decreasing frequency)', () => {
+    const n = 5;
+    const z = makeZipfSampler(n, makeRng(7));
+    const counts = new Array(n).fill(0);
+    for (let i = 0; i < 10000; i++) counts[z()]++;
+    // hot index 0 dominates the cold tail
+    expect(counts[0]).toBeGreaterThan(counts[n - 1] * 3);
+    for (let i = 1; i < n; i++) expect(counts[i - 1]).toBeGreaterThan(counts[i]);
+  });
+
+  test('every sample is a valid in-range index', () => {
+    const n = 8;
+    const z = makeZipfSampler(n, makeRng(3));
+    for (let i = 0; i < 500; i++) {
+      const idx = z();
+      expect(idx).toBeGreaterThanOrEqual(0);
+      expect(idx).toBeLessThan(n);
+    }
+  });
+});
+
+describe('makeMixSampler', () => {
+  test('weights the keys proportionally', () => {
+    const mix = makeMixSampler('read:0.7,write:0.25,meta:0.05', makeRng(11));
+    const tally: Record<string, number> = { read: 0, write: 0, meta: 0 };
+    const N = 20000;
+    for (let i = 0; i < N; i++) tally[mix()]++;
+    expect(tally.read / N).toBeCloseTo(0.7, 1);
+    expect(tally.write / N).toBeCloseTo(0.25, 1);
+    expect(tally.read).toBeGreaterThan(tally.write);
+    expect(tally.write).toBeGreaterThan(tally.meta);
+  });
+
+  test('empty / invalid mix falls back to read:1', () => {
+    const mix = makeMixSampler('', makeRng(1));
+    for (let i = 0; i < 50; i++) expect(mix()).toBe('read');
+  });
+
+  test('trims keys and ignores non-positive weights', () => {
+    const mix = makeMixSampler(' write : 1 , bad:0 , junk', makeRng(5));
+    for (let i = 0; i < 50; i++) expect(mix()).toBe('write');
+  });
+});
diff --git a/packages/perf-harness/src/core/args.ts b/packages/perf-harness/src/core/args.ts
new file mode 100644
index 0000000000..3110e58d24
--- /dev/null
+++ b/packages/perf-harness/src/core/args.ts
@@ -0,0 +1,63 @@
+/**
+ * Minimal, dependency-free argv parsing + coercions.
+ *
+ * Port of `scripts/scale-validate/_lib.mjs` `parseArgs` — but folded into a
+ * single `Argv` shape where positionals land in `_` (the convention the CLI
+ * router and every command reads).
+ *
+ *   --flag value | --flag=value | --flag (boolean true) ; positionals -> _
+ */
+
+export type Argv = Record<string, any> & { _: string[] };
+
+export function parseArgv(raw: string[]): Argv {
+  const args: Argv = { _: [] };
+  for (let i = 0; i < raw.length; i++) {
+    const a = raw[i];
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq !== -1) {
+        args[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const key = a.slice(2);
+        const next = raw[i + 1];
+        if (next === undefined || next.startsWith('--')) {
+          args[key] = true;
+        } else {
+          args[key] = next;
+          i++;
+        }
+      }
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+
+export function asBool(v: any, dflt = false): boolean {
+  if (v === undefined || v === null) return dflt;
+  if (typeof v === 'boolean') return v;
+  const s = String(v).toLowerCase();
+  return s === '1' || s === 'true' || s === 'yes' || s === 'on';
+}
+
+export function asInt(v: any, dflt?: number): number {
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) ? n : dflt;
+}
+
+export function asFloat(v: any, dflt?: number): number {
+  const n = Number.parseFloat(v);
+  return Number.isFinite(n) ? n : dflt;
+}
+
+/**
+ * Print a usage string (to stderr — stdout is reserved for the machine-readable
+ * JSON/JSONL protocol) and return the intended exit code so callers can do
+ * `return usageExit(USAGE)` / `process.exitCode = usageExit(USAGE, 0)`.
+ */
+export function usageExit(usage: string, code = 1): number {
+  console.error(usage);
+  return code;
+}
diff --git a/packages/perf-harness/src/core/config.ts b/packages/perf-harness/src/core/config.ts
new file mode 100644
index 0000000000..ee10172191
--- /dev/null
+++ b/packages/perf-harness/src/core/config.ts
@@ -0,0 +1,96 @@
+/**
+ * Runtime config resolution + the hub-safety guardrail.
+ *
+ * The harness is designed to run against an ISOLATED rig (a dedicated pgpm
+ * docker container on a non-hub port + a dedicated server port). To make it
+ * impossible to accidentally point the load generators at the shared
+ * constructive-hub, every command that dials Postgres or a server port runs the
+ * port through `assertPortAllowed`. The PG port default is 5433 — NEVER 5432.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv, asBool } from './args';
+
+export interface PgConfig {
+  host: string;
+  port: number;
+  user: string;
+  password: string;
+  database: string;
+}
+
+// Ports the shared constructive-hub binds (PG, public/dashboard/private GraphQL,
+// MinIO). Refuse them unless the operator explicitly passes --allow-hub.
+export const HUB_PORTS: number[] = [5432, 3000, 3001, 3002, 9000];
+
+export function assertPortAllowed(port: number, allowHub: boolean, what = 'port'): void {
+  if (allowHub) return;
+  if (HUB_PORTS.includes(port)) {
+    throw new Error(
+      `refusing to use ${what} ${port}: it is a reserved constructive-hub port ` +
+        `(${HUB_PORTS.join(', ')}). This harness targets an isolated rig; ` +
+        `pass --allow-hub to override (danger: may disrupt the live hub).`
+    );
+  }
+}
+
+// CLI flags win over env, env wins over defaults. We NEVER default to 5432.
+export function pgConfigFromArgv(argv: Argv): PgConfig {
+  const num = (v: any, d: number): number => {
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : d;
+  };
+  const cfg: PgConfig = {
+    host: argv['pg-host'] || process.env.PGHOST || 'localhost',
+    port: num(argv['pg-port'] ?? process.env.PGPORT, 5433),
+    user: argv['pg-user'] || process.env.PGUSER || 'postgres',
+    password: argv['pg-password'] ?? process.env.PGPASSWORD ?? 'password',
+    database: argv['pg-database'] || process.env.PGDATABASE || 'constructive'
+  };
+  assertPortAllowed(cfg.port, asBool(argv['allow-hub']), 'pg-port');
+  return cfg;
+}
+
+// Walk up from `startDir` (default cwd) to the first pnpm-workspace.yaml.
+export function findRepoRoot(startDir?: string): string {
+  let dir = path.resolve(startDir || process.cwd());
+  for (;;) {
+    if (fs.existsSync(path.join(dir, 'pnpm-workspace.yaml'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    `could not locate repo root: no pnpm-workspace.yaml walking up from ${startDir || process.cwd()}`
+  );
+}
+
+// Output directory for every artifact (metrics/harness/pg/results/logs/pids).
+export function resolveOutDir(argv: Argv): string {
+  const dir = path.resolve(argv['out-dir'] || './perf-out');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// The command used to boot a server. Default: run the built cnc CLI via node.
+// Override with --server-cmd "node /some/other/entry.js" (whitespace-split).
+export function resolveServerCmd(argv: Argv, repoRoot: string): string[] {
+  const raw = argv['server-cmd'];
+  if (typeof raw === 'string' && raw.trim()) {
+    return raw.trim().split(/\s+/);
+  }
+  return ['node', path.join(repoRoot, 'packages', 'cli', 'dist', 'index.js')];
+}
+
+// Credentials for authenticated load. Email has a seeder default; the password
+// is NEVER given a literal default — flag > PERF_PASSWORD env > null. Commands
+// needing auth must error with guidance when it resolves to null.
+export function resolveCreds(argv: Argv): { email: string; password: string | null } {
+  const emailFlag = typeof argv['email'] === 'string' ? argv['email'].trim() : '';
+  const email = emailFlag || 'seeder@gmail.com';
+  const pwFlag = typeof argv['password'] === 'string' ? argv['password'] : '';
+  const pwEnv = process.env.PERF_PASSWORD || '';
+  const password = pwFlag || pwEnv || null;
+  return { email, password };
+}
diff --git a/packages/perf-harness/src/core/fleetfile.ts b/packages/perf-harness/src/core/fleetfile.ts
new file mode 100644
index 0000000000..b7e0da1e68
--- /dev/null
+++ b/packages/perf-harness/src/core/fleetfile.ts
@@ -0,0 +1,116 @@
+/**
+ * Fleet manifest loading + canary naming + the pure subset algorithm.
+ *
+ * `loadFleet`, `CANARY_PREFIX`, `canaryName` port from
+ * `scripts/scale-validate/_lib.mjs`; `buildSubset` is the pure core of
+ * `scripts/scale-validate/subset-fleet.mjs` (file IO / process.exit stripped —
+ * hard errors throw, soft conditions are collected into `warnings`).
+ */
+import fs from 'node:fs';
+
+export interface Tenant {
+  dbname: string;
+  databaseId?: string;
+  apiHost?: string;
+  authHost?: string;
+  schemas?: string[];
+  appPublicSchema?: string;
+}
+
+export function loadFleet(file: string): { manifest: any; tenants: Tenant[] } {
+  const raw = fs.readFileSync(file, 'utf8');
+  const parsed = JSON.parse(raw);
+  const tenants = Array.isArray(parsed) ? parsed : parsed.tenants;
+  if (!Array.isArray(tenants) || tenants.length === 0) {
+    throw new Error(`fleet file ${file} has no tenants`);
+  }
+  return { manifest: parsed, tenants };
+}
+
+// The token used inside CANARY-<token> rows. MUST match between the canary
+// seeder and the harness sentinel so bleed can be attributed to a foreign
+// tenant. Token == tenant.dbname.
+export const CANARY_PREFIX = 'CANARY-';
+
+export function canaryName(t: Tenant): string {
+  return `${CANARY_PREFIX}${t.dbname}`;
+}
+
+export interface SubsetOpts {
+  blueprints?: number;
+  perBlueprint?: number;
+  tenants?: number;
+  sameBpRegex?: string;
+}
+
+// Blueprint groups: group 0 = the KNOWN-identical blueprint pool (matches
+// sameBpRegex, minus table-drifted tenants; column-drift tenants keep their
+// relname set so they STAY in group 0), groups 1..K = drift-marker groups.
+//
+// Modes:
+//   blueprints=K, perBlueprint=N  -> diversity subset: first K groups, N each.
+//   tenants=N                     -> tenant-count subset: N group-0 tenants.
+export function buildSubset(
+  fleet: Tenant[],
+  drifted: { groups?: Record<string, string[]>; columnDrift?: string[] },
+  o: SubsetOpts
+): { subset: any; tenants: Tenant[]; warnings: string[] } {
+  const warnings: string[] = [];
+  const blueprints = o.blueprints ?? 0;
+  const perBlueprint = o.perBlueprint ?? 5;
+  const tenantCount = o.tenants ?? 0;
+  const sameBpRe = new RegExp(o.sameBpRegex || '^(factory[0-9]+|marketplace_db_tenant1)$');
+
+  const all = fleet;
+  const byName = new Map(all.map((t) => [t.dbname, t]));
+
+  const driftGroups = (drifted && drifted.groups) || {};
+  const driftedNames = new Set<string>();
+  for (const names of Object.values(driftGroups)) names.forEach((n) => driftedNames.add(n));
+
+  const group0 = all
+    .filter((t) => sameBpRe.test(t.dbname) && !driftedNames.has(t.dbname))
+    .map((t) => t.dbname);
+  const groups: string[][] = [group0];
+  for (const g of Object.keys(driftGroups).sort((a, b) => Number(a) - Number(b))) {
+    groups.push(driftGroups[g]);
+  }
+
+  let picked: string[] = [];
+  let label = '';
+  if (blueprints > 0) {
+    if (blueprints > groups.length) {
+      throw new Error(`only ${groups.length} blueprint groups available, asked for ${blueprints}`);
+    }
+    for (let k = 0; k < blueprints; k++) {
+      const take = groups[k].slice(0, perBlueprint);
+      if (take.length < perBlueprint) {
+        warnings.push(`warn: group ${k} has only ${take.length}/${perBlueprint} tenants`);
+      }
+      picked.push(...take);
+    }
+    label = `diversity k=${blueprints} per=${perBlueprint}`;
+  } else if (tenantCount > 0) {
+    picked = group0.slice(0, tenantCount);
+    if (picked.length < tenantCount) {
+      warnings.push(`warn: only ${picked.length}/${tenantCount} undrifted tenants available`);
+    }
+    label = `tenant-count n=${picked.length} (single blueprint)`;
+  } else {
+    throw new Error('one of --blueprints or --tenants is required');
+  }
+
+  const tenants = picked.map((n) => byName.get(n)).filter(Boolean) as Tenant[];
+  const missing = picked.filter((n) => !byName.has(n));
+  if (missing.length) {
+    warnings.push(`warn: ${missing.length} drifted names not in fleet: ${missing.join(',')}`);
+  }
+
+  const subset = {
+    generatedAt: new Date().toISOString(),
+    subset: label,
+    count: tenants.length,
+    tenants
+  };
+  return { subset, tenants, warnings };
+}
diff --git a/packages/perf-harness/src/core/gql.ts b/packages/perf-harness/src/core/gql.ts
new file mode 100644
index 0000000000..fa43482daf
--- /dev/null
+++ b/packages/perf-harness/src/core/gql.ts
@@ -0,0 +1,271 @@
+/**
+ * GraphQL-over-HTTP client + introspection-driven op discovery.
+ * Verbatim ports from `scripts/scale-validate/_lib.mjs`.
+ */
+
+export interface GqlResponse {
+  status: number;
+  ok: boolean;
+  json?: any;
+  text?: string;
+  elapsedMs: number;
+  error?: string;
+}
+
+export interface GqlFetchOpts {
+  host: string;
+  port: number;
+  query: string;
+  variables?: any;
+  token?: string;
+  timeoutMs?: number;
+  gqlPath?: string;
+}
+
+// We put the tenant host in the URL (e.g. api-xxx.localhost) because undici
+// ignores an explicit `host` header. `*.localhost` resolves to loopback, so the
+// connection lands on 127.0.0.1 while the server sees the correct Host header
+// for subdomain routing.
+export async function gqlFetch(opts: GqlFetchOpts): Promise<GqlResponse> {
+  const { host, port, query, variables, token, timeoutMs = 30000, gqlPath = '/graphql' } = opts;
+  const url = `http://${host}:${port}${gqlPath}`;
+  const headers: Record<string, string> = { 'content-type': 'application/json', accept: 'application/json' };
+  if (token) headers.authorization = `Bearer ${token}`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  const start = performance.now();
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(variables ? { query, variables } : { query }),
+      signal: ac.signal
+    });
+    const elapsedMs = performance.now() - start;
+    const ct = res.headers.get('content-type') || '';
+    let json: any = null;
+    let text: any = null;
+    if (ct.includes('json')) {
+      json = await res.json().catch((): any => null);
+    } else {
+      text = await res.text().catch((): any => null);
+      // Some error paths return JSON without the header — try to parse.
+      if (text) {
+        try { json = JSON.parse(text); } catch { /* not json */ }
+      }
+    }
+    return { status: res.status, ok: res.ok, json, text, elapsedMs, error: null };
+  } catch (err: any) {
+    const elapsedMs = performance.now() - start;
+    const error = err && err.name === 'AbortError' ? 'timeout' : (err && (err.code || err.message)) || 'network';
+    return { status: 0, ok: false, json: null, text: null, elapsedMs, error };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function isRotating(resp: GqlResponse): boolean {
+  if (resp.status === 503) {
+    const code = resp.json && resp.json.error && resp.json.error.code;
+    return code === 'SERVICE_ROTATING' || true; // any 503 counts as rotating
+  }
+  return false;
+}
+
+export function gqlErrors(resp: GqlResponse): any[] {
+  return (resp.json && Array.isArray(resp.json.errors)) ? resp.json.errors : [];
+}
+
+export function isUnauthenticated(resp: GqlResponse): boolean {
+  const errs = gqlErrors(resp);
+  for (const e of errs) {
+    const code = e && e.extensions && e.extensions.code;
+    if (code === 'UNAUTHENTICATED' || code === 'FORBIDDEN') return true;
+    const msg = (e && e.message) || '';
+    if (/unauthenticated|not authori[sz]ed|permission denied|jwt|login required|invalid token|expired/i.test(msg)) return true;
+  }
+  if (resp.status === 401 || resp.status === 403) return true;
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Introspection helpers (operate on the JSON introspection result)
+// ---------------------------------------------------------------------------
+export const INTROSPECTION_QUERY = `query Introspect {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    types {
+      kind
+      name
+      fields(includeDeprecated: true) { name args { name type { ...T } } type { ...T } }
+      inputFields { name type { ...T } }
+    }
+  }
+}
+fragment T on __Type {
+  kind name
+  ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name } } } } }
+}`;
+
+export function unwrapType(ref: any): any {
+  let t = ref;
+  while (t && t.ofType) t = t.ofType;
+  return t || null;
+}
+
+export function isNonNull(ref: any): boolean {
+  return !!(ref && ref.kind === 'NON_NULL');
+}
+
+export interface TypeIndex {
+  index: Map<string, any>;
+  queryType: string | null;
+  mutationType: string | null;
+}
+
+export function buildTypeIndex(introspect: any): TypeIndex {
+  const index = new Map<string, any>();
+  const schema = introspect && introspect.__schema;
+  if (!schema) return { index, queryType: null, mutationType: null };
+  for (const t of schema.types) index.set(t.name, t);
+  return {
+    index,
+    queryType: schema.queryType && schema.queryType.name,
+    mutationType: schema.mutationType && schema.mutationType.name
+  };
+}
+
+function findConnectionField(index: Map<string, any>, queryTypeName: string, re: RegExp): string | null {
+  const qt = index.get(queryTypeName);
+  if (!qt) return null;
+  const candidates = (qt.fields || []).filter((f: any) => re.test(f.name));
+  for (const f of candidates) {
+    const named = unwrapType(f.type);
+    const nt = named && index.get(named.name);
+    if (nt && (nt.fields || []).some((sf: any) => sf.name === 'nodes')) return f.name;
+  }
+  return candidates[0] ? candidates[0].name : null;
+}
+
+const SCALAR_SAMPLE = (scalar: string, rand: any): any => {
+  switch (scalar) {
+    case 'Int':
+    case 'BigInt':
+      return 0;
+    case 'Float':
+    case 'BigFloat':
+      return 0;
+    case 'Boolean':
+      return true;
+    default:
+      return `load-${rand}`;
+  }
+};
+
+export interface DiscoveredCreate {
+  name: string;
+  inputTypeName: string;
+  innerName: string;
+  requiredScalars: { name: string; scalar: string; kind: string }[];
+  payloadFieldName: string | null;
+  keySelect: string;
+}
+
+export interface DiscoveredDelete {
+  name: string;
+  inputTypeName: string;
+  key: string;
+}
+
+export interface DiscoveredOps {
+  queryType: string | null;
+  mutationType: string | null;
+  read: string | null;
+  meta: boolean;
+  create: DiscoveredCreate | null;
+  del: DiscoveredDelete | null;
+}
+
+// Discover create/delete/read/meta operations from an introspection result.
+export function discoverOps(introspect: any): DiscoveredOps {
+  const { index, queryType, mutationType } = buildTypeIndex(introspect);
+  const out: DiscoveredOps = { queryType, mutationType, read: null, meta: false, create: null, del: null };
+  if (!queryType) return out;
+
+  // read (categories connection)
+  out.read = findConnectionField(index, queryType, /categor/i);
+
+  // meta (_meta { tables { name } })
+  const qt = index.get(queryType);
+  out.meta = !!(qt && (qt.fields || []).some((f: any) => f.name === '_meta'));
+
+  if (!mutationType) return out;
+  const mt = index.get(mutationType);
+
+  // delete mutation (prefer PK id-based over nodeId-based)
+  const delField = (mt.fields || []).find((f: any) => /^delete.*categor/i.test(f.name) && !/nodeid/i.test(f.name))
+    || (mt.fields || []).find((f: any) => /^delete.*categor/i.test(f.name));
+  if (delField) {
+    const inputArg = (delField.args || []).find((a: any) => a.name === 'input');
+    if (inputArg) {
+      const inputType = index.get(unwrapType(inputArg.type).name);
+      const innerFields = (inputType.inputFields || []).map((f: any) => ({ name: f.name, typeName: unwrapType(f.type).name }));
+      const byId = innerFields.find((f: any) => f.name === 'id');
+      const byNodeId = innerFields.find((f: any) => f.name === 'nodeId');
+      const key = byId ? 'id' : (byNodeId ? 'nodeId' : (innerFields[0] && innerFields[0].name));
+      if (key) {
+        out.del = { name: delField.name, inputTypeName: unwrapType(inputArg.type).name, key };
+      }
+    }
+  }
+
+  // create mutation
+  const createField = (mt.fields || []).find((f: any) => /^create.*categor/i.test(f.name));
+  if (createField) {
+    const inputArg = (createField.args || []).find((a: any) => a.name === 'input');
+    if (inputArg) {
+      const inputTypeName = unwrapType(inputArg.type).name;
+      const inputType = index.get(inputTypeName);
+      const innerField = (inputType.inputFields || []).find((f: any) => {
+        const nt = index.get(unwrapType(f.type).name);
+        return nt && nt.kind === 'INPUT_OBJECT';
+      });
+      if (innerField) {
+        const innerType = index.get(unwrapType(innerField.type).name);
+        const requiredScalars = (innerType.inputFields || [])
+          .filter((f: any) => isNonNull(f.type))
+          .map((f: any) => ({ name: f.name, scalar: unwrapType(f.type).name, kind: unwrapType(f.type).kind }))
+          .filter((f: any) => f.kind === 'SCALAR' || f.kind === 'ENUM');
+        const payloadType = index.get(unwrapType(createField.type).name);
+        const payloadField = (payloadType.fields || []).find((f: any) => {
+          const nt = index.get(unwrapType(f.type).name);
+          return nt && nt.kind === 'OBJECT' && /categor/i.test(nt.name) && (nt.fields || []).some((sf: any) => sf.name === 'id');
+        });
+        out.create = {
+          name: createField.name,
+          inputTypeName,
+          innerName: innerField.name,
+          requiredScalars,
+          payloadFieldName: payloadField ? payloadField.name : null,
+          // which key to select in the payload so we can delete afterwards
+          keySelect: out.del ? out.del.key : 'id'
+        };
+      }
+    }
+  }
+  return out;
+}
+
+// Build the record input object for a create write. `nameValue` is forced onto
+// the `name` column; everything else required gets a type-appropriate value.
+export function buildCreateRecord(create: DiscoveredCreate, nameValue: any, rand: any): Record<string, any> {
+  const rec: Record<string, any> = {};
+  for (const f of create.requiredScalars) {
+    if (f.name === 'name') rec[f.name] = nameValue;
+    else if (f.name === 'slug') rec[f.name] = `load-${rand}`;
+    else rec[f.name] = SCALAR_SAMPLE(f.scalar, rand);
+  }
+  if (rec.name === undefined) rec.name = nameValue; // ensure name present even if not flagged required
+  return rec;
+}
diff --git a/packages/perf-harness/src/core/histogram.ts b/packages/perf-harness/src/core/histogram.ts
new file mode 100644
index 0000000000..441a987523
--- /dev/null
+++ b/packages/perf-harness/src/core/histogram.ts
@@ -0,0 +1,74 @@
+/**
+ * Bucketed latency histogram (bounded memory — safe for multi-hour soaks).
+ * Verbatim port from `scripts/scale-validate/_lib.mjs`.
+ */
+
+export const DEFAULT_BUCKETS: number[] = [
+  1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610,
+  1000, 1600, 2600, 4200, 6800, 11000, 18000, 30000, 60000
+];
+
+const round2 = (n: number): number => Math.round(n * 100) / 100;
+
+export interface HistogramSummary {
+  count: number;
+  min: number;
+  mean: number;
+  p50: number;
+  p95: number;
+  p99: number;
+  max: number;
+}
+
+export class Histogram {
+  buckets: number[];
+  counts: number[];
+  count: number;
+  sum: number;
+  min: number;
+  max: number;
+
+  constructor(buckets: number[] = DEFAULT_BUCKETS) {
+    this.buckets = buckets;
+    this.counts = new Array(buckets.length + 1).fill(0);
+    this.count = 0;
+    this.sum = 0;
+    this.min = Infinity;
+    this.max = 0;
+  }
+
+  record(ms: number): void {
+    this.count++;
+    this.sum += ms;
+    if (ms < this.min) this.min = ms;
+    if (ms > this.max) this.max = ms;
+    let i = 0;
+    while (i < this.buckets.length && ms > this.buckets[i]) i++;
+    this.counts[i]++;
+  }
+
+  percentile(p: number): number {
+    if (this.count === 0) return 0;
+    const target = Math.ceil((p / 100) * this.count);
+    let cum = 0;
+    for (let i = 0; i < this.counts.length; i++) {
+      cum += this.counts[i];
+      if (cum >= target) {
+        return i < this.buckets.length ? this.buckets[i] : Math.round(this.max);
+      }
+    }
+    return Math.round(this.max);
+  }
+
+  summary(): HistogramSummary {
+    return {
+      count: this.count,
+      min: this.count ? round2(this.min) : 0,
+      mean: this.count ? round2(this.sum / this.count) : 0,
+      p50: this.percentile(50),
+      p95: this.percentile(95),
+      p99: this.percentile(99),
+      max: round2(this.max)
+    };
+  }
+}
diff --git a/packages/perf-harness/src/core/pgc.ts b/packages/perf-harness/src/core/pgc.ts
new file mode 100644
index 0000000000..ecd5bf3714
--- /dev/null
+++ b/packages/perf-harness/src/core/pgc.ts
@@ -0,0 +1,46 @@
+/**
+ * Postgres client helpers + error classification.
+ *
+ * `pg` is a real dependency of this package now, so `getPg()` is a plain
+ * require — NOT the @dataplan/pg resolution chain the standalone scripts used.
+ * The classification helpers are ported from
+ * `scripts/scale-validate/tenant-factory.mjs`.
+ */
+import { PgConfig } from './config';
+
+export function getPg(): { Client: any; Pool: any } {
+  // Lazy require so importing this module never loads pg until a caller needs a
+  // real connection (keeps pure/unit paths free of the native binding).
+  return require('pg');
+}
+
+export async function withFreshClient<T>(pg: PgConfig, fn: (client: any) => Promise<T>): Promise<T> {
+  const { Client } = getPg();
+  const client = new Client(pg);
+  await client.connect();
+  try {
+    return await fn(client);
+  } finally {
+    try {
+      await client.end();
+    } catch {
+      // a broken connection's end() can reject — never mask the real error
+    }
+  }
+}
+
+// 57P0x/08006/08003/53300 + a message sniff: connection-class failures (e.g. PG
+// crash recovery / server restart). Callers retry these after a long backoff so
+// a run survives a server restart.
+export function isConnLoss(err: any): boolean {
+  const code = err && err.code;
+  if (['57P01', '57P02', '57P03', '08006', '08003', '53300'].includes(code)) return true;
+  const msg = (err && err.message) || '';
+  return /connection terminated|terminating connection|server closed the connection/i.test(msg);
+}
+
+// 40P01/40001: deadlock / serialization failure — retry the transaction.
+export function isRetryableTxn(err: any): boolean {
+  const code = err && err.code;
+  return code === '40P01' || code === '40001';
+}
diff --git a/packages/perf-harness/src/core/proc.ts b/packages/perf-harness/src/core/proc.ts
new file mode 100644
index 0000000000..8ea93f34c3
--- /dev/null
+++ b/packages/perf-harness/src/core/proc.ts
@@ -0,0 +1,163 @@
+/**
+ * Detached-process + artifact-file utilities.
+ *
+ * New in the package port: replaces the ad-hoc nohup/python-setsid launcher and
+ * the inline child-management the shell orchestrators used. A spawned process
+ * outlives the launching CLI (detached + unref), its stdout/stderr go to a log
+ * file, and its pid is recorded so `run soak status/stop` can find it later.
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+export interface SpawnDetachedOpts {
+  name: string;
+  cmd: string;
+  args: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  outDir: string;
+}
+
+export function spawnDetached(o: SpawnDetachedOpts): { pid: number; logPath: string; pidPath: string } {
+  fs.mkdirSync(o.outDir, { recursive: true });
+  const logPath = path.join(o.outDir, `${o.name}.log`);
+  const pidPath = path.join(o.outDir, `${o.name}.pid`);
+  // Append so a restart keeps history; both stdout and stderr share the fd.
+  const logFd = fs.openSync(logPath, 'a');
+  try {
+    const child = spawn(o.cmd, o.args, {
+      detached: true,
+      stdio: ['ignore', logFd, logFd],
+      // Merge over the parent env so PATH etc. survive; o.env wins on conflicts.
+      env: o.env ? { ...process.env, ...o.env } : process.env,
+      cwd: o.cwd || process.cwd()
+    });
+    child.unref();
+    const pid = child.pid;
+    fs.writeFileSync(pidPath, `${pid}\n`);
+    return { pid, logPath, pidPath };
+  } finally {
+    // The child holds its own dup of the fd; the parent's copy is done.
+    fs.closeSync(logFd);
+  }
+}
+
+export function isAlive(pid: number): boolean {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err: any) {
+    // EPERM => the process exists but is owned by another user (still alive).
+    return !!(err && err.code === 'EPERM');
+  }
+}
+
+export async function stopPid(pid: number, termTimeoutMs = 15000): Promise<'term' | 'kill' | 'gone'> {
+  if (!isAlive(pid)) return 'gone';
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    return 'gone';
+  }
+  const deadline = Date.now() + termTimeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) return 'term';
+    await sleep(200);
+  }
+  if (!isAlive(pid)) return 'term';
+  try {
+    process.kill(pid, 'SIGKILL');
+  } catch {
+    return 'gone';
+  }
+  const killDeadline = Date.now() + 2000;
+  while (Date.now() < killDeadline) {
+    if (!isAlive(pid)) return 'kill';
+    await sleep(100);
+  }
+  return 'kill';
+}
+
+export function readPid(outDir: string, name: string): number | null {
+  const pidPath = path.join(outDir, `${name}.pid`);
+  try {
+    const raw = fs.readFileSync(pidPath, 'utf8').trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+// Resolve once either loopback family accepts a connection. macOS frequently
+// binds `localhost` to ::1 only, so we must probe both 127.0.0.1 and ::1.
+export function waitForPort(port: number, timeoutMs: number): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  const tryConnect = (host: string): Promise<boolean> =>
+    new Promise((resolve) => {
+      const sock = net.connect({ host, port });
+      let done = false;
+      const finish = (ok: boolean): void => {
+        if (done) return;
+        done = true;
+        sock.destroy();
+        resolve(ok);
+      };
+      sock.setTimeout(1000);
+      sock.once('connect', () => finish(true));
+      sock.once('timeout', () => finish(false));
+      sock.once('error', () => finish(false));
+    });
+  return new Promise((resolve, reject) => {
+    const attempt = async (): Promise<void> => {
+      if ((await tryConnect('127.0.0.1')) || (await tryConnect('::1'))) {
+        resolve();
+        return;
+      }
+      if (Date.now() >= deadline) {
+        reject(new Error(`timed out waiting for port ${port} after ${timeoutMs}ms`));
+        return;
+      }
+      setTimeout(() => { void attempt(); }, 250);
+    };
+    void attempt();
+  });
+}
+
+// Parse a JSON-lines file, skipping blank/corrupt lines (e.g. a half-flushed
+// final row from a process killed mid-write).
+export function ensureParentDir(file: string): void {
+  fs.mkdirSync(path.dirname(path.resolve(file)), { recursive: true });
+}
+
+export function readJsonl(file: string): any[] {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  const out: any[] = [];
+  for (const line of raw.split('\n')) {
+    const s = line.trim();
+    if (!s) continue;
+    try {
+      out.push(JSON.parse(s));
+    } catch {
+      // skip corrupt/partial line
+    }
+  }
+  return out;
+}
+
+export function writeDone(outDir: string, name: string, content?: string): void {
+  fs.mkdirSync(outDir, { recursive: true });
+  const donePath = path.join(outDir, `${name}.done`);
+  const body = content !== undefined ? content : new Date().toISOString();
+  fs.writeFileSync(donePath, body.endsWith('\n') ? body : `${body}\n`);
+}
diff --git a/packages/perf-harness/src/core/rng.ts b/packages/perf-harness/src/core/rng.ts
new file mode 100644
index 0000000000..18eed18263
--- /dev/null
+++ b/packages/perf-harness/src/core/rng.ts
@@ -0,0 +1,71 @@
+/**
+ * Seedable RNG + shape samplers — verbatim ports from
+ * `scripts/scale-validate/_lib.mjs`. Reproducible tenant/shape selection so a
+ * soak or ramp can be replayed byte-for-byte from a seed.
+ */
+
+export type Rng = () => number;
+
+// mulberry32 — small, fast, fully deterministic for a given 32-bit seed.
+export function makeRng(seed: number): Rng {
+  let a = (seed >>> 0) || 0x9e3779b9;
+  return function rng(): number {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// zipf: weight_i = 1 / (i + 1) over fleet order; returns an index sampler that
+// favours low indices (the "hot" tenants).
+export function makeZipfSampler(n: number, rng: Rng): () => number {
+  const weights: number[] = [];
+  let total = 0;
+  for (let i = 0; i < n; i++) {
+    const w = 1 / (i + 1);
+    weights.push(w);
+    total += w;
+  }
+  const cum: number[] = [];
+  let acc = 0;
+  for (let i = 0; i < n; i++) {
+    acc += weights[i] / total;
+    cum.push(acc);
+  }
+  return () => {
+    const r = rng();
+    for (let i = 0; i < n; i++) if (r <= cum[i]) return i;
+    return n - 1;
+  };
+}
+
+// "read:0.7,write:0.25,meta:0.05" -> weighted key sampler.
+export function makeMixSampler(mixStr: string, rng: Rng): () => string {
+  const entries: [string, number][] = [];
+  let total = 0;
+  for (const part of String(mixStr).split(',')) {
+    const [k, v] = part.split(':');
+    const w = Number.parseFloat(v);
+    if (k && Number.isFinite(w) && w > 0) {
+      entries.push([k.trim(), w]);
+      total += w;
+    }
+  }
+  if (entries.length === 0) {
+    entries.push(['read', 1]);
+    total = 1;
+  }
+  const cum: [string, number][] = [];
+  let acc = 0;
+  for (const [k, w] of entries) {
+    acc += w / total;
+    cum.push([k, acc]);
+  }
+  return () => {
+    const r = rng();
+    for (const [k, c] of cum) if (r <= c) return k;
+    return cum[cum.length - 1][0];
+  };
+}
diff --git a/packages/perf-harness/src/fleet/__tests__/canary.test.ts b/packages/perf-harness/src/fleet/__tests__/canary.test.ts
new file mode 100644
index 0000000000..01a0cdfbce
--- /dev/null
+++ b/packages/perf-harness/src/fleet/__tests__/canary.test.ts
@@ -0,0 +1,44 @@
+import { valueForColumn } from '../canary';
+
+describe('valueForColumn — required-column value synthesis', () => {
+  const name = 'CANARY-factory7';
+  const slug = 'canary-factory7';
+
+  test('the name column always gets the canary name', () => {
+    expect(valueForColumn({ column_name: 'name', data_type: 'text' }, name, slug)).toBe(name);
+    // name wins even when the declared type would otherwise map elsewhere
+    expect(valueForColumn({ column_name: 'name', data_type: 'integer' }, name, slug)).toBe(name);
+  });
+
+  test('the slug column gets the canary slug', () => {
+    expect(valueForColumn({ column_name: 'slug', data_type: 'text' }, name, slug)).toBe(slug);
+  });
+
+  test('text / char / citext columns get the slug', () => {
+    expect(valueForColumn({ column_name: 'title', data_type: 'character varying' }, name, slug)).toBe(slug);
+    expect(valueForColumn({ column_name: 'body', data_type: 'text' }, name, slug)).toBe(slug);
+    expect(valueForColumn({ column_name: 'handle', data_type: 'USER-DEFINED', udt_name: 'citext' }, name, slug)).toBe(
+      slug
+    );
+  });
+
+  test('boolean columns get true', () => {
+    expect(valueForColumn({ column_name: 'is_active', data_type: 'boolean' }, name, slug)).toBe(true);
+  });
+
+  test('numeric columns get 0', () => {
+    for (const data_type of ['integer', 'bigint', 'smallint', 'numeric', 'double precision', 'real']) {
+      expect(valueForColumn({ column_name: 'qty', data_type }, name, slug)).toBe(0);
+    }
+  });
+
+  test('unknown required column types are unsynthesizable (undefined)', () => {
+    expect(valueForColumn({ column_name: 'meta', data_type: 'jsonb' }, name, slug)).toBeUndefined();
+    expect(valueForColumn({ column_name: 'created_at', data_type: 'timestamp with time zone' }, name, slug)).toBeUndefined();
+    expect(valueForColumn({ column_name: 'tags', data_type: 'ARRAY', udt_name: '_text' }, name, slug)).toBeUndefined();
+  });
+
+  test('missing type metadata falls through to undefined (not a crash)', () => {
+    expect(valueForColumn({ column_name: 'mystery' }, name, slug)).toBeUndefined();
+  });
+});
diff --git a/packages/perf-harness/src/fleet/__tests__/provision.test.ts b/packages/perf-harness/src/fleet/__tests__/provision.test.ts
new file mode 100644
index 0000000000..bfe9ac6d35
--- /dev/null
+++ b/packages/perf-harness/src/fleet/__tests__/provision.test.ts
@@ -0,0 +1,93 @@
+import { classifyRetry, computeShape, retryBackoffMs, ShapeRelation, stripSchemaHashPrefix } from '../provision';
+
+describe('stripSchemaHashPrefix', () => {
+  test('strips through the first -<8 hex>- segment', () => {
+    expect(stripSchemaHashPrefix('marketplace-db-tenant1-5e6b13b2-app-public')).toBe('app-public');
+    expect(stripSchemaHashPrefix('factory12-aabbccdd-app-private')).toBe('app-private');
+  });
+
+  test('leaves control-plane schemas (no hash segment) unchanged', () => {
+    expect(stripSchemaHashPrefix('services_public')).toBe('services_public');
+    expect(stripSchemaHashPrefix('public')).toBe('public');
+  });
+});
+
+describe('computeShape — shape fingerprint', () => {
+  const relnames = ['categories', 'order_items', 'orders', 'products', 'reviews'];
+  const rowsFor = (schema: string): ShapeRelation[] => relnames.map((relname) => ({ nspname: schema, relname }));
+
+  test('same relnames, different schema-hash prefixes => same fingerprint', () => {
+    const a = computeShape(rowsFor('factory1-aabbccdd-app-public'));
+    const b = computeShape(rowsFor('factory2-11223344-app-public'));
+    expect(a.fingerprint).toBe(b.fingerprint);
+    expect(a.pairs.length).toBe(5);
+    // pairs are the logical (stripped) schema, not the physical one
+    expect(a.pairs.every(([schema]) => schema === 'app-public')).toBe(true);
+  });
+
+  test('an extra relation changes the fingerprint (table drift)', () => {
+    const base = computeShape(rowsFor('factory1-aabbccdd-app-public'));
+    const drifted = computeShape([
+      ...rowsFor('factory1-aabbccdd-app-public'),
+      { nspname: 'factory1-aabbccdd-app-public', relname: 'drift_marker_g1' }
+    ]);
+    expect(drifted.fingerprint).not.toBe(base.fingerprint);
+  });
+
+  test('deterministic regardless of input row order', () => {
+    const ordered = computeShape(rowsFor('t-aabbccdd-app-public'));
+    const shuffled = computeShape([...rowsFor('t-aabbccdd-app-public')].reverse());
+    expect(shuffled.fingerprint).toBe(ordered.fingerprint);
+  });
+
+  test('an empty relation set is stable and non-empty digest', () => {
+    expect(computeShape([]).fingerprint).toBe(computeShape([]).fingerprint);
+    expect(computeShape([]).pairs).toEqual([]);
+  });
+});
+
+describe('classifyRetry — connection loss vs deadlock vs fatal', () => {
+  test('connection-class codes are retriable and flagged connLost', () => {
+    for (const code of ['57P01', '57P02', '57P03', '08006', '08003', '53300']) {
+      expect(classifyRetry({ code })).toEqual({ connLost: true, retriable: true });
+    }
+  });
+
+  test('deadlock / serialization are retriable but NOT connLost (short backoff)', () => {
+    expect(classifyRetry({ code: '40P01' })).toEqual({ connLost: false, retriable: true });
+    expect(classifyRetry({ code: '40001' })).toEqual({ connLost: false, retriable: true });
+  });
+
+  test('a terminated-connection message with no code is treated as connLost', () => {
+    expect(classifyRetry({ message: 'server closed the connection unexpectedly' })).toEqual({
+      connLost: true,
+      retriable: true
+    });
+    expect(classifyRetry({ message: 'terminating connection due to administrator command' }).connLost).toBe(true);
+  });
+
+  test('an ordinary error (unique_violation) is not retriable', () => {
+    expect(classifyRetry({ code: '23505', message: 'duplicate key value' })).toEqual({
+      connLost: false,
+      retriable: false
+    });
+  });
+});
+
+describe('retryBackoffMs', () => {
+  test('connection loss backs off ~10s * attempt', () => {
+    expect(retryBackoffMs(true, 1, 0)).toBe(10000);
+    expect(retryBackoffMs(true, 2, 0)).toBe(20000);
+    expect(retryBackoffMs(true, 3, 0)).toBe(30000);
+  });
+
+  test('deadlock backs off ~100ms * attempt', () => {
+    expect(retryBackoffMs(false, 1, 0)).toBe(100);
+    expect(retryBackoffMs(false, 3, 0)).toBe(300);
+  });
+
+  test('adds jitter in [0,100)', () => {
+    expect(retryBackoffMs(false, 1, 0.999)).toBe(100 + 99);
+    expect(retryBackoffMs(true, 1, 0.5)).toBe(10000 + 50);
+  });
+});
diff --git a/packages/perf-harness/src/fleet/__tests__/teardown.test.ts b/packages/perf-harness/src/fleet/__tests__/teardown.test.ts
new file mode 100644
index 0000000000..36a309479e
--- /dev/null
+++ b/packages/perf-harness/src/fleet/__tests__/teardown.test.ts
@@ -0,0 +1,27 @@
+import { buildWhere } from '../teardown';
+
+describe('buildWhere — tenant selection SQL', () => {
+  test('--only matches an exact name (single param)', () => {
+    expect(buildWhere({ only: 'factory101', prefix: 'factory', keep: 40 })).toEqual({
+      sql: 'name = $1',
+      params: ['factory101']
+    });
+  });
+
+  test('prefix/keep drops every `<prefix><n>` above --keep', () => {
+    const w = buildWhere({ only: null, prefix: 'factory', keep: 40 });
+    expect(w.sql).toBe(`name ~ ('^' || $1 || '[0-9]+$') AND (regexp_replace(name, '^' || $1, ''))::int > $2`);
+    expect(w.params).toEqual(['factory', 40]);
+  });
+
+  test('--only takes precedence over prefix/keep', () => {
+    const w = buildWhere({ only: 'marketplace_db_tenant1', prefix: 'factory', keep: 40 });
+    expect(w.sql).toBe('name = $1');
+    expect(w.params).toEqual(['marketplace_db_tenant1']);
+  });
+
+  test('a custom prefix/keep is threaded through as params (no interpolation)', () => {
+    const w = buildWhere({ only: undefined, prefix: 'loadtest', keep: 0 });
+    expect(w.params).toEqual(['loadtest', 0]);
+  });
+});
diff --git a/packages/perf-harness/src/fleet/canary.ts b/packages/perf-harness/src/fleet/canary.ts
new file mode 100644
index 0000000000..34dde4978f
--- /dev/null
+++ b/packages/perf-harness/src/fleet/canary.ts
@@ -0,0 +1,170 @@
+/**
+ * fleet canary — seed one CANARY-<dbname> row into each tenant's app-public
+ * categories table (superuser pg client). Idempotent. Port of
+ * `scripts/scale-validate/canary-seed.mjs`.
+ *
+ * The harness bleed-sentinel reads a tenant's categories and FAILS HARD if it
+ * ever sees a CANARY-<other-dbname> row — so these rows must exist for the
+ * sentinel to have anything to detect cross-tenant bleed with.
+ *
+ * NOT NULL columns without a default are discovered via information_schema and
+ * filled (name -> the canary name, slug/other text -> a canary slug).
+ *
+ *   perf-harness fleet canary --fleet fleet.json
+ *   perf-harness fleet canary --fleet fleet.json --cleanup
+ */
+import { Argv, asBool, usageExit } from '../core/args';
+import { pgConfigFromArgv } from '../core/config';
+import { canaryName, loadFleet } from '../core/fleetfile';
+import { withFreshClient } from '../core/pgc';
+
+export const USAGE = `perf-harness fleet canary — insert/remove CANARY-<dbname> rows in each tenant's categories
+
+Options:
+  --fleet <file>   fleet manifest from \`fleet discover\` (required)
+  --table <name>   target table (default: categories)
+  --cleanup        remove the canary rows instead of inserting
+  --pg-* / PG*     connection overrides
+  --allow-hub      permit a constructive-hub port
+  --help
+`;
+
+const REQUIRED_COLS_SQL = `
+SELECT column_name, data_type, udt_name
+FROM information_schema.columns
+WHERE table_schema = $1 AND table_name = $2
+  AND is_nullable = 'NO'
+  AND column_default IS NULL
+ORDER BY ordinal_position;
+`;
+
+const TABLE_EXISTS_SQL = `
+SELECT 1 FROM information_schema.tables
+WHERE table_schema = $1 AND table_name = $2 AND table_type = 'BASE TABLE';
+`;
+
+export function valueForColumn(
+  col: { column_name: string; data_type?: string; udt_name?: string },
+  nameValue: string,
+  slugValue: string
+): any {
+  if (col.column_name === 'name') return nameValue;
+  if (col.column_name === 'slug') return slugValue;
+  const t = (col.data_type || '').toLowerCase();
+  const u = (col.udt_name || '').toLowerCase();
+  if (t.includes('char') || t === 'text' || u === 'citext') return slugValue;
+  if (t.includes('bool')) return true;
+  if (t.includes('int') || t === 'numeric' || t.includes('double') || t.includes('real')) return 0;
+  // Unknown required column type we cannot safely synthesize.
+  return undefined;
+}
+
+export async function run(argv: Argv): Promise<number> {
+  if (asBool(argv.help) || !argv.fleet) {
+    console.error(USAGE);
+    return !argv.fleet && !asBool(argv.help) ? 1 : 0;
+  }
+
+  try {
+    const table = typeof argv.table === 'string' ? argv.table : 'categories';
+    const cleanup = asBool(argv.cleanup);
+    const { tenants } = loadFleet(argv.fleet);
+    const cfg = pgConfigFromArgv(argv);
+
+    const report: any = { table, mode: cleanup ? 'cleanup' : 'seed', results: [] };
+    await withFreshClient(cfg, async (client) => {
+      for (const t of tenants) {
+        const schema = t.appPublicSchema;
+        const entry: any = { dbname: t.dbname, schema, status: 'ok' };
+        if (!schema) {
+          entry.status = 'skipped';
+          entry.reason = 'no app-public schema';
+          report.results.push(entry);
+          continue;
+        }
+        const exists = await client.query(TABLE_EXISTS_SQL, [schema, table]);
+        if (exists.rowCount === 0) {
+          entry.status = 'skipped';
+          entry.reason = `no ${table} table (blank tenant)`;
+          report.results.push(entry);
+          continue;
+        }
+
+        const name = canaryName(t);
+        // canary token == tenant.dbname (see core/fleetfile); slug is a
+        // filesystem-safe rendering of it.
+        const slug = `canary-${t.dbname}`.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+        const qSchema = `"${schema}"`;
+        const qTable = `"${table}"`;
+
+        if (cleanup) {
+          const del = await client.query(`DELETE FROM ${qSchema}.${qTable} WHERE name = $1`, [name]);
+          entry.removed = del.rowCount;
+          report.results.push(entry);
+          continue;
+        }
+
+        // Idempotent: skip if a canary row already exists.
+        const already = await client.query(
+          `SELECT count(*)::int AS n FROM ${qSchema}.${qTable} WHERE name = $1`,
+          [name]
+        );
+        if (already.rows[0].n > 0) {
+          entry.status = 'exists';
+          entry.inserted = 0;
+          report.results.push(entry);
+          continue;
+        }
+
+        const cols = await client.query(REQUIRED_COLS_SQL, [schema, table]);
+        const colNames: string[] = [];
+        const values: any[] = [];
+        const placeholders: string[] = [];
+        let bad: string | null = null;
+        let idx = 1;
+        const seen = new Set<string>();
+        for (const col of cols.rows) {
+          const v = valueForColumn(col, name, slug);
+          if (v === undefined) {
+            bad = col.column_name;
+            break;
+          }
+          colNames.push(`"${col.column_name}"`);
+          values.push(v);
+          placeholders.push(`$${idx++}`);
+          seen.add(col.column_name);
+        }
+        // Ensure `name` is always written even if it was not flagged required.
+        if (!seen.has('name')) {
+          colNames.push('"name"');
+          values.push(name);
+          placeholders.push(`$${idx++}`);
+        }
+        if (bad) {
+          entry.status = 'skipped';
+          entry.reason = `unsupported required column: ${bad}`;
+          report.results.push(entry);
+          continue;
+        }
+        const ins = await client.query(
+          `INSERT INTO ${qSchema}.${qTable} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`,
+          values
+        );
+        entry.inserted = ins.rowCount;
+        entry.name = name;
+        report.results.push(entry);
+      }
+    });
+
+    const seeded = report.results.filter((r: any) => r.inserted > 0).length;
+    const existed = report.results.filter((r: any) => r.status === 'exists').length;
+    const removed = report.results.reduce((a: number, r: any) => a + (r.removed || 0), 0);
+    const skipped = report.results.filter((r: any) => r.status === 'skipped').length;
+    report.summary = { seeded, existed, removed, skipped, tenants: tenants.length };
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return 0;
+  } catch (err: any) {
+    process.stderr.write(`[canary-seed] ERROR: ${err && err.stack ? err.stack : err}\n`);
+    return 1;
+  }
+}
diff --git a/packages/perf-harness/src/fleet/discover.ts b/packages/perf-harness/src/fleet/discover.ts
new file mode 100644
index 0000000000..859deb2838
--- /dev/null
+++ b/packages/perf-harness/src/fleet/discover.ts
@@ -0,0 +1,105 @@
+/**
+ * fleet discover — print a JSON fleet manifest describing every tenant
+ * database. Port of `scripts/scale-validate/fleet.mjs`.
+ *
+ * For each tenant database (metaschema_public.database where name like the
+ * --like pattern) it resolves databaseId, the api/auth hosts (from
+ * services_public.domains) and the physical schemas of the `api` API.
+ *
+ *   perf-harness fleet discover > fleet.json
+ *   perf-harness fleet discover --like 'marketplace%' --pretty
+ *   perf-harness fleet discover --pg-port 5433 --out fleet.json
+ */
+import fs from 'node:fs';
+
+import { Argv, asBool, usageExit } from '../core/args';
+import { pgConfigFromArgv } from '../core/config';
+import { withFreshClient } from '../core/pgc';
+import { ensureParentDir } from '../core/proc';
+import { Tenant } from '../core/fleetfile';
+
+export const USAGE = `perf-harness fleet discover — emit JSON fleet manifest from the control-plane DB
+
+Options:
+  --like <pattern>   database name filter (default: '%' — all databases; e.g. 'marketplace%' to narrow)
+  --out <file>       write JSON here instead of stdout
+  --pretty           pretty-print JSON
+  --pg-host/--pg-port/--pg-user/--pg-password/--pg-database  connection overrides
+  --allow-hub        permit a constructive-hub port (default refuses 5432/3000/3001/3002/9000)
+  --help
+`;
+
+const FLEET_SQL = `
+SELECT
+  d.name AS dbname,
+  d.id::text AS database_id,
+  (SELECT dom.subdomain || '.' || dom.domain
+     FROM services_public.domains dom
+     WHERE dom.database_id = d.id AND dom.subdomain LIKE 'api-%'
+     ORDER BY dom.subdomain LIMIT 1) AS api_host,
+  (SELECT dom.subdomain || '.' || dom.domain
+     FROM services_public.domains dom
+     WHERE dom.database_id = d.id AND dom.subdomain LIKE 'auth-%'
+     ORDER BY dom.subdomain LIMIT 1) AS auth_host,
+  COALESCE((
+    SELECT array_agg(s.schema_name ORDER BY s.schema_name)
+      FROM services_public.apis a
+      JOIN services_public.api_schemas aps ON aps.api_id = a.id AND aps.database_id = a.database_id
+      JOIN metaschema_public.schema s ON s.id = aps.schema_id
+     WHERE a.database_id = d.id AND a.name = 'api'
+  ), ARRAY[]::text[]) AS schemas
+FROM metaschema_public.database d
+WHERE d.name LIKE $1
+ORDER BY d.name;
+`;
+
+export async function run(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) return usageExit(USAGE, 0);
+  try {
+    // Default widened from the original fleet.mjs 'marketplace%' to '%': the
+    // canonical validation fleet (committed fleet.json, VALIDATION-REPORT.md)
+    // and the tenants `fleet provision` creates (factory*) are only captured
+    // by a match-all pattern. Pass --like to narrow (e.g. 'marketplace%').
+    const like = typeof argv.like === 'string' ? argv.like : '%';
+    const pretty = asBool(argv.pretty);
+    const cfg = pgConfigFromArgv(argv);
+    const rows = await withFreshClient(cfg, async (client) => {
+      const res = await client.query(FLEET_SQL, [like]);
+      return res.rows;
+    });
+
+    const tenants: Tenant[] = rows.map((r: any) => {
+      const schemas: string[] = r.schemas || [];
+      const appPublicSchema = schemas.find((s) => /-app-public$/.test(s)) || schemas[0] || null;
+      return {
+        dbname: r.dbname,
+        databaseId: r.database_id,
+        apiHost: r.api_host,
+        authHost: r.auth_host,
+        schemas,
+        appPublicSchema
+      };
+    });
+
+    const manifest = {
+      generatedAt: new Date().toISOString(),
+      like,
+      pg: { host: cfg.host, port: cfg.port, database: cfg.database },
+      count: tenants.length,
+      tenants
+    };
+
+    const json = JSON.stringify(manifest, null, pretty ? 2 : 0);
+    if (typeof argv.out === 'string') {
+      ensureParentDir(argv.out);
+      fs.writeFileSync(argv.out, `${json}\n`, 'utf8');
+      process.stderr.write(`[fleet] wrote ${tenants.length} tenants to ${argv.out}\n`);
+    } else {
+      process.stdout.write(`${json}\n`);
+    }
+    return 0;
+  } catch (err: any) {
+    process.stderr.write(`[fleet] ERROR: ${err && err.stack ? err.stack : err}\n`);
+    return 1;
+  }
+}
diff --git a/packages/perf-harness/src/fleet/drift.ts b/packages/perf-harness/src/fleet/drift.ts
new file mode 100644
index 0000000000..189baaa6b5
--- /dev/null
+++ b/packages/perf-harness/src/fleet/drift.ts
@@ -0,0 +1,105 @@
+/**
+ * fleet drift — apply deliberate shape drift to seeded tenants so the fleet
+ * spans multiple blueprints. Port of `scripts/scale-validate/drift-tenants.mjs`
+ * (inline pg defaults/parser replaced with core config + args; --pg-* and --help
+ * added; output written under --out-dir).
+ *
+ * The pooling shape-fingerprint hashes [logical schema, relname] pairs — only
+ * ADDING A RELATION changes a tenant's blueprint.
+ *
+ *   --groups K --per-group N   assign K drift groups; group g (1-based) gets a
+ *                              marker TABLE drift_marker_g<g> in app-public →
+ *                              K distinct blueprints (group 0 = undrifted).
+ *   --column-drift N           additionally give N tenants a benign EXTRA COLUMN
+ *                              on categories (same relname set → SAME blueprint;
+ *                              exercises the documented fingerprint limitation).
+ *
+ * Writes drifted.json describing the assignment. Idempotent (IF NOT EXISTS).
+ *   perf-harness fleet drift --groups 6 --per-group 4 --column-drift 2
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv, asBool, asInt, usageExit } from '../core/args';
+import { PgConfig, pgConfigFromArgv, resolveOutDir } from '../core/config';
+import { withFreshClient } from '../core/pgc';
+
+export const USAGE = `perf-harness fleet drift — apply deliberate shape drift so the fleet spans multiple blueprints
+
+Options:
+  --groups <K>         assign K table-drift groups (drift_marker_g<g> per group)
+  --per-group <N>      tenants per group (default: 4)
+  --column-drift <N>   give N tenants a benign extra column (same blueprint)
+  --out <file>         write assignment JSON here (default: <out-dir>/drifted.json)
+  --out-dir <dir>      artifact directory (default: ./perf-out)
+  --pg-* / PG*         connection overrides
+  --allow-hub          permit a constructive-hub port
+  --help
+`;
+
+// Tenant app-public schemas, oldest first for stable assignment.
+const TENANT_SCHEMAS_SQL = `
+    SELECT db.name AS dbname, s.schema_name
+    FROM metaschema_public.database db
+    JOIN metaschema_public.schema s ON s.database_id = db.id
+    WHERE db.name NOT IN ('constructive') AND s.schema_name LIKE '%-app-public'
+    ORDER BY db.name`;
+
+export async function run(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) return usageExit(USAGE, 0);
+
+  const groups = asInt(argv.groups, 0);
+  const perGroup = asInt(argv['per-group'], 4);
+  const columnDrift = asInt(argv['column-drift'], 0);
+
+  let cfg: PgConfig;
+  try {
+    cfg = pgConfigFromArgv(argv);
+  } catch (err) {
+    console.error(err);
+    return 1;
+  }
+
+  const outFile =
+    typeof argv.out === 'string' ? path.resolve(argv.out) : path.join(resolveOutDir(argv), 'drifted.json');
+
+  try {
+    await withFreshClient(cfg, async (client) => {
+      const { rows } = await client.query(TENANT_SCHEMAS_SQL);
+
+      const assignment: { groups: Record<string, string[]>; columnDrift: string[] } = { groups: {}, columnDrift: [] };
+      let idx = 0;
+
+      for (let g = 1; g <= groups; g++) {
+        assignment.groups[g] = [];
+        for (let n = 0; n < perGroup && idx < rows.length; n++, idx++) {
+          const { dbname, schema_name } = rows[idx];
+          await client.query(
+            `CREATE TABLE IF NOT EXISTS "${schema_name.replace(/"/g, '""')}"."drift_marker_g${g}" (id serial PRIMARY KEY, note text)`
+          );
+          assignment.groups[g].push(dbname);
+          console.error(`table-drift g${g}: ${dbname}`);
+        }
+      }
+
+      for (let n = 0; n < columnDrift && idx < rows.length; n++, idx++) {
+        const { dbname, schema_name } = rows[idx];
+        await client.query(
+          `ALTER TABLE "${schema_name.replace(/"/g, '""')}".categories ADD COLUMN IF NOT EXISTS drift_col_only text`
+        );
+        assignment.columnDrift.push(dbname);
+        console.error(`column-drift (same blueprint, documents fingerprint limit): ${dbname}`);
+      }
+
+      fs.mkdirSync(path.dirname(outFile), { recursive: true });
+      fs.writeFileSync(outFile, JSON.stringify(assignment, null, 2));
+      console.error(
+        `done: ${groups} table-drift groups × ${perGroup}, ${columnDrift} column-drift; assignment → ${outFile}`
+      );
+    });
+    return 0;
+  } catch (err) {
+    console.error(err);
+    return 1;
+  }
+}
diff --git a/packages/perf-harness/src/fleet/provision.ts b/packages/perf-harness/src/fleet/provision.ts
new file mode 100644
index 0000000000..fb3584a578
--- /dev/null
+++ b/packages/perf-harness/src/fleet/provision.ts
@@ -0,0 +1,433 @@
+/**
+ * fleet provision — the fast-path tenant factory. Port of
+ * `scripts/scale-validate/tenant-factory.mjs`.
+ *
+ * Creates blueprint-identical marketplace tenants directly via SQL, reusing the
+ * SAME control-plane procedures the GraphQL seeder ultimately invokes, but
+ * WITHOUT the GraphQL/undici layer (and its 300s HTTP cap). Per tenant, in one
+ * committed transaction:
+ *
+ *   1. metaschema_generators.provision_database(...)   — db + domains + apis +
+ *        site + modules + the app_public/app_private application schemas.
+ *   2. metaschema_private.bootstrap_owner_into_database(...) — copies the owner
+ *        user + primary email + password_hash from the control-plane source
+ *        database so password sign-in works.
+ *   3. INSERT metaschema_modules_public.blueprint (copy of the reference
+ *        definition) + metaschema_modules_public.construct_blueprint(
+ *        blueprint_id, app_public_schema_id) — builds the marketplace tables.
+ *
+ * Session GUC: the module install triggers call
+ * metaschema_private.ensure_super_constructive(), which RAISES unless
+ * `constructive.allow_super_constructive = 'true'`. We set it per-transaction.
+ *
+ *   perf-harness fleet provision --count 5 --prefix factory --blueprint marketplace
+ *   perf-harness fleet provision --validate factory1   # shape check vs reference
+ */
+import { createHash, randomBytes } from 'node:crypto';
+
+import { Argv, asBool, asInt, usageExit } from '../core/args';
+import { PgConfig, pgConfigFromArgv } from '../core/config';
+import { getPg, isConnLoss, isRetryableTxn } from '../core/pgc';
+
+export const USAGE = `perf-harness fleet provision — create blueprint-identical marketplace tenants via SQL
+
+Options:
+  --count <n>          number of tenants to create (default: 1)
+  --prefix <name>      tenant name prefix (default: factory)
+  --blueprint <name>   reference blueprint name (default: marketplace)
+  --reference <db>     reference tenant database (default: marketplace_db_tenant1)
+  --source-db <db>     control-plane source database (default: constructive)
+  --domain <domain>    subdomain suffix (default: localhost)
+  --concurrency <n>    parallel workers (default: 1)
+  --max-retries <n>    retries on connection loss / deadlock (default: 3)
+  --start-index <n>    first tenant index (default: next free after prefix)
+  --dry-run            ROLLBACK each tenant transaction (shape check only)
+  --validate <db>      compare a tenant's api shape-fingerprint to the reference
+  --pg-* / PG*         connection overrides
+  --allow-hub          permit a constructive-hub port
+  --help
+`;
+
+interface ProvisionOpts {
+  count: number;
+  prefix: string;
+  blueprint: string;
+  reference: string;
+  sourceDb: string;
+  domain: string;
+  concurrency: number;
+  maxRetries: number;
+  dryRun: boolean;
+  validate: string | null;
+  startIndex: number | null;
+}
+
+function readOpts(argv: Argv): ProvisionOpts {
+  return {
+    count: asInt(argv.count, 1),
+    prefix: typeof argv.prefix === 'string' ? argv.prefix : 'factory',
+    blueprint: typeof argv.blueprint === 'string' ? argv.blueprint : 'marketplace',
+    reference: typeof argv.reference === 'string' ? argv.reference : 'marketplace_db_tenant1',
+    sourceDb: typeof argv['source-db'] === 'string' ? argv['source-db'] : 'constructive',
+    domain: typeof argv.domain === 'string' ? argv.domain : 'localhost',
+    concurrency: asInt(argv.concurrency, 1),
+    maxRetries: asInt(argv['max-retries'], 3),
+    dryRun: asBool(argv['dry-run']),
+    validate: typeof argv.validate === 'string' ? argv.validate : null,
+    startIndex: argv['start-index'] !== undefined ? asInt(argv['start-index'], null) : null
+  };
+}
+
+const now = (): bigint => process.hrtime.bigint();
+const ms = (t: bigint): string => `${(Number(t) / 1e6).toFixed(0)}ms`;
+
+// ---------------------------------------------------------------------------
+// retry classification (deadlock/serialization vs connection-class failures)
+// ---------------------------------------------------------------------------
+// 40P01/40001: deadlock/serialization -> short backoff. 57P0x/08006/08003/53300
+// + message sniff: connection-class (e.g. PG crash recovery) -> long backoff so
+// the run survives a server restart. Classifiers live in core/pgc.
+export function classifyRetry(err: any): { connLost: boolean; retriable: boolean } {
+  const connLost = isConnLoss(err);
+  return { connLost, retriable: connLost || isRetryableTxn(err) };
+}
+
+export function retryBackoffMs(connLost: boolean, attempt: number, rand: number = Math.random()): number {
+  return (connLost ? 10000 : 100) * attempt + Math.floor(rand * 100);
+}
+
+// ---------------------------------------------------------------------------
+// shape fingerprint (step 3.i): compare the logical [schema, relname] set of a
+// tenant's `api` API to the reference tenant's — same set => same fingerprint =>
+// same bp: key. Mirrors graphql/server/src/middleware/blueprint.ts:
+// stripSchemaHashPrefix + fingerprintFromRelations. The physical-schema hash
+// prefix is stripped in JS (not SQL) so the property is unit-testable.
+// ---------------------------------------------------------------------------
+const SHAPE_SQL = `
+  WITH api_schema AS (
+    SELECT s.schema_name
+      FROM metaschema_public.database d
+      JOIN services_public.apis a ON a.database_id = d.id AND a.name = 'api'
+      JOIN services_public.api_schemas x ON x.api_id = a.id
+      JOIN metaschema_public.schema s ON s.id = x.schema_id
+     WHERE d.name = $1
+  )
+  SELECT n.nspname, c.relname
+    FROM api_schema aps
+    JOIN pg_namespace n ON n.nspname = aps.schema_name
+    JOIN pg_class c ON c.relnamespace = n.oid AND c.relkind IN ('r','v','m','p')
+   ORDER BY 1, 2`;
+
+export interface ShapeRelation {
+  nspname: string;
+  relname: string;
+}
+
+// Strip the tenant hash prefix from a physical schema name (mirror of the
+// server's stripSchemaHashPrefix): `<dashed-dbname>-<8hex>-<logical>` ->
+// `<logical>`; control-plane schemas without the segment are unchanged.
+export function stripSchemaHashPrefix(name: string): string {
+  const match = /-[0-9a-f]{8}-/.exec(name);
+  if (!match) return name;
+  return name.slice(match.index + match[0].length);
+}
+
+// sha256 over the sorted [logicalSchema, relname] pairs (same algorithm as the
+// server's fingerprintFromRelations). Returns the pairs too, for reporting.
+export function computeShape(rows: ShapeRelation[]): { pairs: [string, string][]; fingerprint: string } {
+  const pairs: [string, string][] = rows.map((row) => [stripSchemaHashPrefix(row.nspname), row.relname]);
+  pairs.sort((a, b) => (a[0] !== b[0] ? (a[0] < b[0] ? -1 : 1) : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0));
+  return { pairs, fingerprint: createHash('sha256').update(JSON.stringify(pairs)).digest('hex') };
+}
+
+async function shapeOf(pool: any, dbName: string): Promise<{ pairs: [string, string][]; fingerprint: string }> {
+  const r = await pool.query(SHAPE_SQL, [dbName]);
+  return computeShape(r.rows);
+}
+
+async function validateShape(pool: any, opts: ProvisionOpts): Promise<boolean> {
+  const ref = await shapeOf(pool, opts.reference);
+  const cand = await shapeOf(pool, opts.validate);
+  const same = ref.fingerprint === cand.fingerprint;
+  console.error(`\n=== SHAPE CHECK: "${opts.validate}" vs reference "${opts.reference}" ===`);
+  console.error(`reference api relations (${ref.pairs.length}):`);
+  for (const [s, r] of ref.pairs) console.error(`    ${s}.${r}`);
+  console.error(`candidate api relations (${cand.pairs.length}):`);
+  for (const [s, r] of cand.pairs) console.error(`    ${s}.${r}`);
+  console.error(`reference shapeFingerprint: ${ref.fingerprint}`);
+  console.error(`candidate shapeFingerprint: ${cand.fingerprint}`);
+  console.error(`IDENTICAL SHAPE => same bp: key expected: ${same ? 'YES' : 'NO'}`);
+  return same;
+}
+
+// ---------------------------------------------------------------------------
+// reference loading
+// ---------------------------------------------------------------------------
+async function loadReference(pool: any, opts: ProvisionOpts): Promise<any> {
+  const ref = await pool.query(
+    `SELECT d.id AS db_id, d.owner_id
+       FROM metaschema_public.database d
+      WHERE d.name = $1`,
+    [opts.reference]
+  );
+  if (ref.rows.length === 0) throw new Error(`reference database "${opts.reference}" not found`);
+  const { db_id: refDbId, owner_id: ownerId } = ref.rows[0];
+
+  const prov = await pool.query(
+    `SELECT modules, options, domain
+       FROM metaschema_modules_public.database_provision_module
+      WHERE database_id = $1
+      ORDER BY created_at
+      LIMIT 1`,
+    [refDbId]
+  );
+  if (prov.rows.length === 0)
+    throw new Error(`no database_provision_module row for reference "${opts.reference}"`);
+  const modules = prov.rows[0].modules;
+  const options = prov.rows[0].options;
+
+  const bp = await pool.query(
+    `SELECT name, display_name, definition
+       FROM metaschema_modules_public.blueprint
+      WHERE database_id = $1 AND name = $2`,
+    [refDbId, opts.blueprint]
+  );
+  if (bp.rows.length === 0)
+    throw new Error(`reference blueprint "${opts.blueprint}" not found on "${opts.reference}"`);
+  const blueprint = bp.rows[0];
+
+  const src = await pool.query(`SELECT id FROM metaschema_public.database WHERE name = $1`, [opts.sourceDb]);
+  if (src.rows.length === 0) throw new Error(`source database "${opts.sourceDb}" not found`);
+  const sourceDbId = src.rows[0].id;
+
+  return { refDbId, ownerId, modules, options, blueprint, sourceDbId };
+}
+
+async function nextStartIndex(pool: any, prefix: string): Promise<number> {
+  const r = await pool.query(
+    `SELECT COALESCE(MAX((regexp_replace(name, '^' || $1, ''))::int), 0) AS mx
+       FROM metaschema_public.database
+      WHERE name ~ ('^' || $1 || '[0-9]+$')`,
+    [prefix]
+  );
+  return (r.rows[0].mx || 0) + 1;
+}
+
+// ---------------------------------------------------------------------------
+// per-tenant provisioning (one committed transaction)
+// ---------------------------------------------------------------------------
+async function createTenant(pool: any, ref: any, opts: ProvisionOpts, index: number): Promise<any> {
+  const name = `${opts.prefix}${index}`;
+  const subdomain = `${name}-${randomBytes(4).toString('hex')}`;
+
+  let attempt = 0;
+  for (;;) {
+    attempt++;
+    const client = await pool.connect();
+    const t: any = {};
+    try {
+      await client.query('BEGIN');
+      await client.query('SET LOCAL statement_timeout = 0');
+      await client.query('SET LOCAL idle_in_transaction_session_timeout = 0');
+      await client.query('SET LOCAL lock_timeout = 0');
+      await client.query(`SET LOCAL constructive.allow_super_constructive = 'true'`);
+
+      // Phase 1: provision_database
+      let s = now();
+      const provRes = await client.query(
+        `SELECT metaschema_generators.provision_database($1,$2,$3,$4,$5::jsonb,$6::jsonb) AS db_id`,
+        [name, ref.ownerId, subdomain, opts.domain, JSON.stringify(ref.modules), JSON.stringify(ref.options)]
+      );
+      const dbId = provRes.rows[0].db_id;
+      t.provision = now() - s;
+
+      // Phase 2: bootstrap owner (password sign-in path)
+      s = now();
+      await client.query(`SELECT metaschema_private.bootstrap_owner_into_database($1,$2,$3,false)`, [
+        dbId,
+        ref.sourceDbId,
+        ref.ownerId
+      ]);
+      t.bootstrap = now() - s;
+
+      // Phase 3: blueprint copy + construct
+      s = now();
+      const bpRes = await client.query(
+        `INSERT INTO metaschema_modules_public.blueprint
+           (owner_id, database_id, name, display_name, definition)
+         VALUES ($1,$2,$3,$4,$5::jsonb)
+         RETURNING id`,
+        [ref.ownerId, dbId, ref.blueprint.name, ref.blueprint.display_name, JSON.stringify(ref.blueprint.definition)]
+      );
+      const blueprintId = bpRes.rows[0].id;
+      const schemaRes = await client.query(
+        `SELECT id, schema_name FROM metaschema_public.schema
+          WHERE database_id = $1 AND name = 'app_public'`,
+        [dbId]
+      );
+      if (schemaRes.rows.length === 0) throw new Error('app_public schema not found after provision');
+      const appPublicSchemaId = schemaRes.rows[0].id;
+      const appPublicPhysical = schemaRes.rows[0].schema_name;
+      await client.query(`SELECT metaschema_modules_public.construct_blueprint($1,$2)`, [
+        blueprintId,
+        appPublicSchemaId
+      ]);
+      t.blueprint = now() - s;
+
+      // Phase 4: in-txn verification
+      const verify: any = {};
+      verify.schemaCount = (
+        await client.query(`SELECT count(*)::int AS c FROM metaschema_public.schema WHERE database_id=$1`, [dbId])
+      ).rows[0].c;
+      verify.appTables = (
+        await client.query(
+          `SELECT array_agg(c.relname::text ORDER BY c.relname) AS tables
+             FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace
+            WHERE n.nspname=$1 AND c.relkind='r'`,
+          [appPublicPhysical]
+        )
+      ).rows[0].tables;
+      verify.domains = (
+        await client.query(
+          `SELECT array_agg(d.subdomain || '.' || d.domain ORDER BY d.subdomain) AS hosts
+             FROM services_public.domains d WHERE d.database_id=$1
+              AND (d.subdomain LIKE 'api-%' OR d.subdomain LIKE 'auth-%')`,
+          [dbId]
+        )
+      ).rows[0].hosts;
+
+      if (opts.dryRun) await client.query('ROLLBACK');
+      else await client.query('COMMIT');
+
+      return {
+        ok: true,
+        name,
+        subdomain,
+        dbId,
+        appPublicPhysical,
+        apiHost: `api-${subdomain}.${opts.domain}`,
+        authHost: `auth-${subdomain}.${opts.domain}`,
+        timings: t,
+        verify,
+        attempt,
+        rolledBack: opts.dryRun
+      };
+    } catch (err: any) {
+      try {
+        await client.query('ROLLBACK');
+      } catch {
+        // rollback of an already-broken txn can throw — ignore
+      }
+      const { connLost, retriable } = classifyRetry(err);
+      if (retriable && attempt <= opts.maxRetries) {
+        const backoff = retryBackoffMs(connLost, attempt);
+        console.error(`  [${name}] ${err.code} (attempt ${attempt}) — retrying in ${backoff}ms`);
+        await new Promise((r) => setTimeout(r, backoff));
+        continue;
+      }
+      return { ok: false, name, subdomain, error: err.message, code: err.code, attempt };
+    } finally {
+      client.release();
+    }
+  }
+}
+
+export async function run(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) return usageExit(USAGE, 0);
+  const opts = readOpts(argv);
+
+  let cfg: PgConfig;
+  try {
+    cfg = pgConfigFromArgv(argv);
+  } catch (err) {
+    console.error(err);
+    return 1;
+  }
+
+  const { Pool } = getPg();
+  const pool = new Pool({ ...cfg, max: Math.max(2, opts.concurrency + 1) });
+  // An idle pooled client dying (PG crash/restart) must not take down the run.
+  pool.on('error', (e: any) => console.error(`  [pool] idle client error (continuing): ${e.message}`));
+
+  try {
+    if (opts.validate) {
+      const ok = await validateShape(pool, opts);
+      return ok ? 0 : 1;
+    }
+
+    const ref = await loadReference(pool, opts);
+    const start = opts.startIndex ?? (await nextStartIndex(pool, opts.prefix));
+    const indices = Array.from({ length: opts.count }, (_, k) => start + k);
+
+    console.error(
+      `tenant-factory: creating ${opts.count} tenant(s) prefix=${opts.prefix} indices=${start}..${
+        start + opts.count - 1
+      } blueprint=${opts.blueprint} concurrency=${opts.concurrency}${opts.dryRun ? ' [DRY-RUN]' : ''}`
+    );
+    console.error(`  owner=${ref.ownerId} source-db=${ref.sourceDbId} modules=${ref.modules.length} items`);
+
+    const results: any[] = [];
+    const wallStart = now();
+
+    // simple concurrency pool
+    let cursor = 0;
+    const worker = async (): Promise<void> => {
+      for (;;) {
+        const i = cursor++;
+        if (i >= indices.length) return;
+        const idx = indices[i];
+        const tStart = now();
+        const res = await createTenant(pool, ref, opts, idx);
+        const wall = now() - tStart;
+        res.wall = wall;
+        results.push(res);
+        if (res.ok) {
+          const okTables = Array.isArray(res.verify.appTables) && res.verify.appTables.length === 5;
+          console.error(
+            `  [${res.name}] OK db=${res.dbId} schemas=${res.verify.schemaCount} ` +
+              `appTables=${(res.verify.appTables || []).join(',')} ${okTables ? '✓' : '✗5'} ` +
+              `(prov ${ms(res.timings.provision)} boot ${ms(res.timings.bootstrap)} ` +
+              `bp ${ms(res.timings.blueprint)} wall ${ms(wall)}${
+                res.attempt > 1 ? ` retries=${res.attempt - 1}` : ''
+              })`
+          );
+        } else {
+          console.error(`  [${res.name}] FAILED code=${res.code} ${res.error}`);
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: opts.concurrency }, () => worker()));
+
+    const wall = now() - wallStart;
+    const ok = results.filter((r) => r.ok);
+    const failed = results.filter((r) => !r.ok);
+    const totalSec = Number(wall) / 1e9;
+    const perMin = ok.length > 0 ? (ok.length / totalSec) * 60 : 0;
+
+    console.error(`\n=== SUMMARY ===`);
+    console.error(`created ${ok.length}/${opts.count} tenants in ${totalSec.toFixed(1)}s`);
+    if (ok.length) {
+      const avg = (sel: (r: any) => any): number => ok.reduce((a, r) => a + Number(sel(r)), 0) / ok.length / 1e6;
+      console.error(
+        `  avg per-tenant: provision ${avg((r) => r.timings.provision).toFixed(0)}ms ` +
+          `bootstrap ${avg((r) => r.timings.bootstrap).toFixed(0)}ms ` +
+          `blueprint ${avg((r) => r.timings.blueprint).toFixed(0)}ms ` +
+          `wall ${avg((r) => r.wall).toFixed(0)}ms`
+      );
+      console.error(`  throughput: ${perMin.toFixed(2)} tenants/minute (concurrency=${opts.concurrency})`);
+      console.error(`  api hosts:`);
+      for (const r of ok) console.error(`    ${r.name}: ${r.apiHost}  (auth: ${r.authHost})`);
+    }
+    if (failed.length) {
+      console.error(`  FAILURES:`);
+      for (const r of failed) console.error(`    ${r.name}: [${r.code}] ${r.error}`);
+      return 1;
+    }
+    return 0;
+  } catch (err) {
+    console.error(err);
+    return 1;
+  } finally {
+    await pool.end();
+  }
+}
diff --git a/packages/perf-harness/src/fleet/teardown.ts b/packages/perf-harness/src/fleet/teardown.ts
new file mode 100644
index 0000000000..4a84a556ac
--- /dev/null
+++ b/packages/perf-harness/src/fleet/teardown.ts
@@ -0,0 +1,175 @@
+/**
+ * fleet teardown — tear down factory tenants above --keep (catalog-wall
+ * remediation: the rig's PG cannot introspect a 100+-tenant catalog, so the
+ * fleet is trimmed to a size the VM can serve). Port of
+ * `scripts/scale-validate/drop-tenants.mjs` (inline pg defaults replaced with
+ * core config + args; --pg-* and --help added).
+ *
+ * Per tenant, in one transaction:
+ *   1. capture its physical schema names from metaschema_public.schema
+ *   2. DELETE FROM metaschema_public.database (control-plane FKs CASCADE;
+ *      metaschema delete triggers may drop physical objects — requires the
+ *      constructive.allow_super_constructive GUC)
+ *   3. DROP SCHEMA IF EXISTS ... CASCADE for any physical schema that survived
+ * Then VACUUM ANALYZE the hot catalogs and report the new catalog size.
+ *
+ *   perf-harness fleet teardown --prefix factory --keep 40 [--dry-run] [--only factory101]
+ */
+import { Argv, asBool, asInt, usageExit } from '../core/args';
+import { PgConfig, pgConfigFromArgv } from '../core/config';
+import { getPg } from '../core/pgc';
+
+export const USAGE = `perf-harness fleet teardown — drop factory tenants above --keep and reclaim catalog
+
+Options:
+  --prefix <name>   tenant name prefix (default: factory)
+  --keep <n>        keep tenants with index <= n (default: 40)
+  --only <db>       drop exactly this one tenant instead of prefix/keep
+  --dry-run         ROLLBACK each drop (report only)
+  --pg-* / PG*      connection overrides
+  --allow-hub       permit a constructive-hub port
+  --help
+`;
+
+// Hot catalogs to VACUUM ANALYZE after a drop batch so pg_class introspection
+// stays fast at scale.
+const VACUUM_CATALOGS = ['pg_class', 'pg_attribute', 'pg_proc', 'pg_constraint', 'pg_policy', 'pg_namespace', 'pg_depend', 'pg_type'];
+
+export interface TeardownWhere {
+  sql: string;
+  params: any[];
+}
+
+// --only targets exactly one tenant; otherwise drop every `<prefix><n>` tenant
+// whose numeric index exceeds --keep.
+export function buildWhere(opts: { only?: string | null; prefix: string; keep: number }): TeardownWhere {
+  if (opts.only) {
+    return { sql: `name = $1`, params: [opts.only] };
+  }
+  return {
+    sql: `name ~ ('^' || $1 || '[0-9]+$') AND (regexp_replace(name, '^' || $1, ''))::int > $2`,
+    params: [opts.prefix, opts.keep]
+  };
+}
+
+const qid = (s: string): string => `"${s.replace(/"/g, '""')}"`;
+
+async function dropOne(pool: any, row: any, dry: boolean): Promise<{ ok: boolean; error?: string }> {
+  const client = await pool.connect();
+  const t0 = Date.now();
+  try {
+    await client.query('BEGIN');
+    await client.query('SET LOCAL statement_timeout = 0');
+    await client.query('SET LOCAL lock_timeout = 0');
+    await client.query(`SET LOCAL constructive.allow_super_constructive = 'true'`);
+
+    const schemas = (
+      await client.query(`SELECT schema_name FROM metaschema_public.schema WHERE database_id=$1`, [row.id])
+    ).rows.map((r: any) => r.schema_name);
+
+    await client.query(`DELETE FROM metaschema_public.database WHERE id=$1`, [row.id]);
+
+    let survivors = 0;
+    for (const s of schemas) {
+      const exists = await client.query(`SELECT 1 FROM pg_namespace WHERE nspname=$1`, [s]);
+      if (exists.rows.length) {
+        survivors++;
+        await client.query(`DROP SCHEMA IF EXISTS ${qid(s)} CASCADE`);
+      }
+    }
+
+    // pg_partman registers partitioned tables by NAME in partman.part_config —
+    // not schema-scoped, not FK-cascaded — and schema hashes are deterministic
+    // per dbname, so a leftover row blocks re-provisioning a reused tenant name
+    // (unique_violation on parent_table). Clean them with the schemas.
+    if (schemas.length) {
+      const patterns = schemas.map((s: string) => `${s}.%`);
+      try {
+        await client.query(`DELETE FROM partman.part_config_sub WHERE sub_parent LIKE ANY($1)`, [patterns]);
+      } catch {
+        /* part_config_sub may not exist */
+      }
+      try {
+        const del = await client.query(`DELETE FROM partman.part_config WHERE parent_table LIKE ANY($1)`, [patterns]);
+        if (del.rowCount) console.error(`  [${row.name}] cleaned ${del.rowCount} partman.part_config row(s)`);
+      } catch {
+        /* partman may not be installed */
+      }
+    }
+
+    if (dry) await client.query('ROLLBACK');
+    else await client.query('COMMIT');
+    console.error(
+      `  [${row.name}] dropped (schemas=${schemas.length} survivors-dropped=${survivors}) ${Date.now() - t0}ms${dry ? ' [DRY]' : ''}`
+    );
+    return { ok: true };
+  } catch (e: any) {
+    try {
+      await client.query('ROLLBACK');
+    } catch {
+      // rollback of an already-broken txn can throw — ignore
+    }
+    console.error(`  [${row.name}] FAILED: ${e.code || ''} ${e.message}`);
+    return { ok: false, error: e.message };
+  } finally {
+    client.release();
+  }
+}
+
+export async function run(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) return usageExit(USAGE, 0);
+
+  const prefix = typeof argv.prefix === 'string' ? argv.prefix : 'factory';
+  const keep = asInt(argv.keep, 40);
+  const only = typeof argv.only === 'string' ? argv.only : null;
+  const dry = asBool(argv['dry-run']);
+
+  let cfg: PgConfig;
+  try {
+    cfg = pgConfigFromArgv(argv);
+  } catch (err) {
+    console.error(err);
+    return 1;
+  }
+
+  const { Pool } = getPg();
+  const pool = new Pool({ ...cfg, max: 2 });
+  pool.on('error', (e: any) => console.error(`[pool] idle client error (continuing): ${e.message}`));
+
+  try {
+    const where = buildWhere({ only, prefix, keep });
+    const { rows } = await pool.query(
+      `SELECT id, name FROM metaschema_public.database WHERE ${where.sql}
+     ORDER BY (regexp_replace(name, '[^0-9]', '', 'g'))::int NULLS LAST`,
+      where.params
+    );
+    console.error(`drop-tenants: ${rows.length} tenant(s) to drop${dry ? ' [DRY-RUN]' : ''}`);
+
+    let ok = 0;
+    for (const row of rows) {
+      const r = await dropOne(pool, row, dry);
+      if (r.ok) ok++;
+    }
+    console.error(`dropped ${ok}/${rows.length}`);
+
+    if (!dry && ok > 0) {
+      console.error('VACUUM ANALYZE hot catalogs...');
+      for (const cat of VACUUM_CATALOGS) {
+        await pool.query(`VACUUM ANALYZE ${cat}`);
+      }
+    }
+
+    const stats = await pool.query(`
+    SELECT (SELECT count(*) FROM pg_class) AS classes,
+           (SELECT count(*) FROM pg_attribute) AS attrs,
+           (SELECT count(*) FROM pg_namespace) AS namespaces,
+           (SELECT count(*) FROM metaschema_public.database) AS databases`);
+    console.error(`catalog now: ${JSON.stringify(stats.rows[0])}`);
+    return 0;
+  } catch (err) {
+    console.error(err);
+    return 1;
+  } finally {
+    await pool.end();
+  }
+}
diff --git a/packages/perf-harness/src/index.ts b/packages/perf-harness/src/index.ts
new file mode 100644
index 0000000000..e5b76b7d99
--- /dev/null
+++ b/packages/perf-harness/src/index.ts
@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * perf-harness — Constructive performance / regression CLI.
+ *
+ * Non-interactive, script-friendly router:
+ *   perf-harness <domain> <subcommand> [flags]
+ *
+ * Each `src/commands/<domain>.ts` self-registers via `{ domain, summary,
+ * subcommands }`. This shell is deliberately a hand-rolled router over
+ * `core/args.parseArgv` rather than the `inquirerer` CLI class the sibling
+ * `packages/cli` uses: the domain contract returns numeric exit codes (0/1/2),
+ * routing is 2–3 positionals deep (`run soak start|status|stop`), and the
+ * automation contract forbids interactive prompts — none of which the
+ * prompt-driven `inquirerer` shell accommodates cleanly. See DESIGN.md
+ * "Command registration contract" (a working non-interactive CLI beats
+ * framework conformance).
+ *
+ * stdout is reserved for the machine-readable JSON/JSONL protocol emitted by
+ * subcommands; help/usage (human output) goes to stderr via `usageExit`.
+ */
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+import * as fleet from './commands/fleet';
+import * as load from './commands/load';
+import * as measure from './commands/measure';
+import * as regression from './commands/regression';
+import * as report from './commands/report';
+import * as run from './commands/run';
+import { Argv, parseArgv, usageExit } from './core/args';
+
+interface Subcommand {
+  usage: string;
+  run(argv: Argv): Promise<number>;
+}
+
+interface Domain {
+  domain: string;
+  summary: string;
+  subcommands: Record<string, Subcommand>;
+}
+
+// Ordered for help rendering; the registry below is keyed off each `.domain`.
+const DOMAIN_LIST: Domain[] = [fleet, load, measure, run, report, regression];
+
+const domains: Record<string, Domain> = {};
+for (const d of DOMAIN_LIST) domains[d.domain] = d;
+
+function readVersion(): string {
+  // Published layout puts package.json next to index.js (publishConfig.directory
+  // = dist); built/dev layouts put it one level up. Walk up until the first
+  // package.json with a version is found.
+  let dir = __dirname;
+  for (let i = 0; i < 6; i++) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+      if (pkg && typeof pkg.version === 'string') return pkg.version;
+    } catch {
+      // not here — keep walking up
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return '0.0.0';
+}
+
+function topLevelHelp(): string {
+  const w = Math.max(...DOMAIN_LIST.map((d) => d.domain.length));
+  const lines = DOMAIN_LIST.map((d) => `  ${d.domain.padEnd(w)}  ${d.summary}`);
+  return [
+    'perf-harness — Constructive performance / regression harness',
+    '',
+    'Usage: perf-harness <domain> <subcommand> [flags]',
+    '',
+    'Domains:',
+    ...lines,
+    '',
+    "Run 'perf-harness <domain> --help' to list a domain's subcommands.",
+    'Global flags: --help/-h, --version.',
+    'Common flags: --allow-hub, --out-dir <dir>, --pg-host/--pg-port/--pg-user/--pg-password/--pg-database.'
+  ].join('\n');
+}
+
+function domainHelp(d: Domain): string {
+  const usageLines = Object.values(d.subcommands).map((s) => `  ${s.usage}`);
+  return [
+    `perf-harness ${d.domain} — ${d.summary}`,
+    '',
+    `Usage: perf-harness ${d.domain} <subcommand> [flags]`,
+    '',
+    'Subcommands:',
+    ...usageLines
+  ].join('\n');
+}
+
+async function main(): Promise<number> {
+  const raw = process.argv.slice(2);
+  const argv = parseArgv(raw);
+
+  // Detect meta-flags from the RAW argv: parseArgv treats `--flag value` as
+  // key=value, which would otherwise let `--version`/`--help` swallow a
+  // following positional. These flags are always standalone booleans.
+  if (raw.includes('--version')) {
+    console.log(readVersion());
+    return 0;
+  }
+  const wantHelp = raw.includes('--help') || raw.includes('-h');
+
+  const domainName = argv._[0];
+  if (domainName === 'help' && !argv._[1]) return usageExit(topLevelHelp(), 0);
+  if (!domainName) return usageExit(topLevelHelp(), wantHelp ? 0 : 1);
+
+  const domain = domains[domainName];
+  if (!domain) return usageExit(`Unknown domain: ${domainName}\n\n${topLevelHelp()}`, 1);
+
+  const subName = argv._[1];
+  if (subName === 'help') return usageExit(domainHelp(domain), 0);
+  if (!subName) return usageExit(domainHelp(domain), wantHelp ? 0 : 1);
+
+  const sub = domain.subcommands[subName];
+  if (!sub) {
+    if (wantHelp) return usageExit(domainHelp(domain), 0);
+    return usageExit(`Unknown subcommand: ${domainName} ${subName}\n\n${domainHelp(domain)}`, 1);
+  }
+
+  // Pass the full argv through unchanged: subcommands read their own
+  // positionals (e.g. `run soak` dispatches on argv._[2] = start|status|stop)
+  // and handle their own `--help`.
+  const code = await sub.run(argv);
+  return typeof code === 'number' ? code : 0;
+}
+
+main()
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((err) => {
+    console.error(err && err.message ? err.message : String(err));
+    process.exitCode = 1;
+  });
diff --git a/packages/perf-harness/src/load/__tests__/harness.test.ts b/packages/perf-harness/src/load/__tests__/harness.test.ts
new file mode 100644
index 0000000000..41f635b5e2
--- /dev/null
+++ b/packages/perf-harness/src/load/__tests__/harness.test.ts
@@ -0,0 +1,126 @@
+import { DEFAULT_OPS, findTokenSelection, scoreTokenField } from '../harness';
+
+// A minimal introspection type index: Map<typeName, { kind, name, fields }>.
+// `findTokenSelection` follows each field's named type through the index, so
+// every referenced type (scalars included) must be present.
+function buildIndex(types: any[]): Map<string, any> {
+  const index = new Map<string, any>();
+  for (const t of types) index.set(t.name, t);
+  return index;
+}
+
+const STRING = { kind: 'SCALAR', name: 'String' };
+const scalar = (name: string) => ({ name, type: { kind: 'SCALAR', name: 'String' } });
+const object = (name: string, typeName: string) => ({ name, type: { kind: 'OBJECT', name: typeName } });
+
+describe('scoreTokenField', () => {
+  test('accessToken exact match scores highest', () => {
+    expect(scoreTokenField('accessToken')).toBe(4);
+    expect(scoreTokenField('accesstoken')).toBe(4);
+    expect(scoreTokenField('ACCESSTOKEN')).toBe(4);
+  });
+
+  test('contains-accessToken beats plain token beats jwt beats nothing', () => {
+    expect(scoreTokenField('userAccessToken')).toBe(3);
+    expect(scoreTokenField('token')).toBe(2);
+    expect(scoreTokenField('refreshToken')).toBe(2);
+    expect(scoreTokenField('jwt')).toBe(1);
+    expect(scoreTokenField('jwtBlob')).toBe(1);
+    expect(scoreTokenField('id')).toBe(0);
+    expect(scoreTokenField('clientMutationId')).toBe(0);
+  });
+
+  test('strict ordering: accessToken > userAccessToken > token > jwt > other', () => {
+    const s = scoreTokenField;
+    expect(s('accessToken')).toBeGreaterThan(s('userAccessToken'));
+    expect(s('userAccessToken')).toBeGreaterThan(s('token'));
+    expect(s('token')).toBeGreaterThan(s('jwt'));
+    expect(s('jwt')).toBeGreaterThan(s('email'));
+  });
+});
+
+describe('findTokenSelection', () => {
+  test('descends one level into an object field (result { accessToken })', () => {
+    const index = buildIndex([
+      STRING,
+      { kind: 'OBJECT', name: 'SignInResult', fields: [scalar('accessToken')] },
+      { kind: 'OBJECT', name: 'SignInPayload', fields: [scalar('clientMutationId'), object('result', 'SignInResult')] }
+    ]);
+    const sel = findTokenSelection(index, 'SignInPayload');
+    expect(sel).not.toBeNull();
+    expect(sel.selection).toBe('result { accessToken }');
+    expect(sel.path).toEqual(['result', 'accessToken']);
+    expect(sel.score).toBe(4);
+  });
+
+  test('prefers a direct scalar accessToken over a plain token (early return at score>=3)', () => {
+    const index = buildIndex([
+      STRING,
+      { kind: 'OBJECT', name: 'SignInPayloadFlat', fields: [scalar('token'), scalar('accessToken')] }
+    ]);
+    const sel = findTokenSelection(index, 'SignInPayloadFlat');
+    expect(sel.selection).toBe('accessToken');
+    expect(sel.path).toEqual(['accessToken']);
+    expect(sel.score).toBe(4);
+  });
+
+  test('falls back to a nested jwt field when no higher-scoring field exists', () => {
+    const index = buildIndex([
+      STRING,
+      { kind: 'OBJECT', name: 'JwtResult', fields: [scalar('jwt')] },
+      { kind: 'OBJECT', name: 'JwtPayload', fields: [scalar('clientMutationId'), object('result', 'JwtResult')] }
+    ]);
+    const sel = findTokenSelection(index, 'JwtPayload');
+    expect(sel.selection).toBe('result { jwt }');
+    expect(sel.path).toEqual(['result', 'jwt']);
+    expect(sel.score).toBe(1);
+  });
+
+  test('returns null when no token-ish field is present', () => {
+    const index = buildIndex([
+      STRING,
+      { kind: 'OBJECT', name: 'BoringPayload', fields: [scalar('id'), scalar('clientMutationId')] }
+    ]);
+    expect(findTokenSelection(index, 'BoringPayload')).toBeNull();
+  });
+
+  test('returns null when the payload type is not in the index', () => {
+    const index = buildIndex([STRING]);
+    expect(findTokenSelection(index, 'Nonexistent')).toBeNull();
+  });
+});
+
+describe('DEFAULT_OPS', () => {
+  test('has the canonical categories fallback shape', () => {
+    const ops = DEFAULT_OPS();
+    expect(ops.read).toBe('categories');
+    expect(ops.meta).toBe(true);
+    expect(ops.queryType).toBeNull();
+    expect(ops.mutationType).toBeNull();
+    expect(ops.create).toEqual({
+      name: 'createCategory',
+      inputTypeName: 'CreateCategoryInput',
+      innerName: 'category',
+      requiredScalars: [
+        { name: 'name', scalar: 'String', kind: 'SCALAR' },
+        { name: 'slug', scalar: 'String', kind: 'SCALAR' }
+      ],
+      payloadFieldName: 'category',
+      keySelect: 'id'
+    });
+    expect(ops.del).toEqual({ name: 'deleteCategory', inputTypeName: 'DeleteCategoryInput', key: 'id' });
+  });
+
+  test('is a factory — each call returns an independent object the harness can mutate', () => {
+    const a = DEFAULT_OPS();
+    const b = DEFAULT_OPS();
+    expect(a).not.toBe(b);
+    expect(a.create).not.toBe(b.create);
+    // The harness downgrades a tenant by setting ops.read = null after a probe;
+    // that must not bleed into the next fallback.
+    a.read = null;
+    a.create = null;
+    expect(DEFAULT_OPS().read).toBe('categories');
+    expect(DEFAULT_OPS().create).not.toBeNull();
+  });
+});
diff --git a/packages/perf-harness/src/load/churn.ts b/packages/perf-harness/src/load/churn.ts
new file mode 100644
index 0000000000..86bc1683fd
--- /dev/null
+++ b/packages/perf-harness/src/load/churn.ts
@@ -0,0 +1,127 @@
+/**
+ * load/churn — drive schema-cache churn during a soak.
+ *
+ * Every --interval-notify-sec it issues a NOTIFY on channel "schema:update"
+ * (via pg_notify) with a random tenant's databaseId as payload. The server
+ * LISTENs on "schema:update" and flushes that database's cached PostGraphile
+ * instance(s), forcing rebuilds — exercising eviction/drain/build paths.
+ *
+ * A provisioning hook fires every --provision-every-sec but only logs a marker;
+ * actual tenant provisioning is handled separately by the orchestrator.
+ *
+ * Timeline events are emitted as JSON lines to stdout (start | notify |
+ * notify-error | provision-marker | stop).
+ *
+ * Faithful port of `scripts/scale-validate/churn-driver.mjs`. Deviations (all
+ * DESIGN-mandated): a fresh pg Client per NOTIFY comes from `core/pgc`
+ * `withFreshClient`; the PG connection runs through the hub guardrail
+ * (`pgConfigFromArgv`); and the script becomes a `run(argv): Promise<number>`
+ * subcommand — on signal it emits the stop line and returns 0 (natural loop
+ * drain) instead of calling `process.exit(0)`.
+ */
+import { Argv, asBool, asInt } from '../core/args';
+import { pgConfigFromArgv } from '../core/config';
+import { loadFleet } from '../core/fleetfile';
+import { withFreshClient } from '../core/pgc';
+
+const nowIso = (): string => new Date().toISOString();
+
+const HELP = `perf-harness load churn — NOTIFY schema:update churn + provisioning markers
+
+Options:
+  --fleet <file>              fleet manifest (required)
+  --interval-notify-sec <n>   NOTIFY period (default 20; 0 disables)
+  --provision-every-sec <n>   provisioning-marker period (default 0 = off)
+  --duration-sec <n>          run length (default 3600; 0 = until SIGINT)
+  --channel <name>            notify channel (default schema:update)
+  --seed <n>                  RNG seed
+  --pg-* / PG*                connection overrides (pg-port default 5433, never 5432)
+  --allow-hub                 permit a hub PG port (danger)
+  --help
+`;
+
+export async function runChurn(argv: Argv): Promise<number> {
+  if (asBool(argv.help) || !argv.fleet) {
+    process.stderr.write(HELP);
+    return (!argv.fleet && !asBool(argv.help)) ? 1 : 0;
+  }
+
+  try {
+    const intervalNotifySec = asInt(argv['interval-notify-sec'], 20);
+    const provisionEverySec = asInt(argv['provision-every-sec'], 0);
+    const durationSec = asInt(argv['duration-sec'], 3600);
+    const channel = typeof argv.channel === 'string' ? argv.channel : 'schema:update';
+    let seed = asInt(argv.seed, (Date.now() & 0x7fffffff));
+    const { tenants } = loadFleet(argv.fleet);
+    const cfg = pgConfigFromArgv(argv);
+
+    const emit = (obj: any): void => { process.stdout.write(`${JSON.stringify({ at: nowIso(), ...obj })}\n`); };
+    // Same LCG the original used for churn selection — deliberately NOT the core
+    // mulberry32; kept identical so a seeded churn timeline replays byte-for-byte.
+    const rand = (): number => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+    const pickTenant = () => tenants[Math.floor(rand() * tenants.length)];
+
+    let notifies = 0;
+    let provisions = 0;
+    let failures = 0;
+    const timers: any[] = [];
+
+    emit({ t: 'start', channel, intervalNotifySec, provisionEverySec, durationSec, tenants: tenants.length, pid: process.pid });
+
+    if (intervalNotifySec > 0) {
+      timers.push(setInterval(async () => {
+        const tenant = pickTenant();
+        try {
+          // Fresh connection per query: with long NOTIFY intervals a persistent
+          // client gets reaped by idle_session_timeout (57P05) and its socket
+          // error would kill the driver mid-soak. Hourly connects are free. The
+          // per-client 'error' listener swallows late socket errors on end().
+          await withFreshClient(cfg, (client) => {
+            client.on('error', () => {});
+            return client.query('SELECT pg_notify($1, $2)', [channel, tenant.databaseId]);
+          });
+          notifies++;
+          emit({ t: 'notify', channel, databaseId: tenant.databaseId, dbname: tenant.dbname, seq: notifies });
+        } catch (err: any) {
+          failures++;
+          emit({ t: 'notify-error', databaseId: tenant.databaseId, dbname: tenant.dbname, error: String((err && err.message) || err) });
+        }
+      }, intervalNotifySec * 1000));
+    }
+
+    if (provisionEverySec > 0) {
+      timers.push(setInterval(() => {
+        provisions++;
+        // Provisioning hook — the orchestrator performs the real provision; we
+        // only mark the timeline so churn events can be correlated.
+        emit({ t: 'provision-marker', seq: provisions, note: 'provisioning handled by orchestrator' });
+      }, provisionEverySec * 1000));
+    }
+
+    let resolveDone: (code: number) => void;
+    const done = new Promise<number>((res) => { resolveDone = res; });
+
+    let stopped = false;
+    const stop = (reason: string): void => {
+      if (stopped) return;
+      stopped = true;
+      for (const t of timers) clearInterval(t);
+      emit({ t: 'stop', reason, notifies, provisions, failures });
+      // per-query connections — nothing persistent to close
+    };
+
+    let stopTimer: any = null;
+    if (durationSec > 0) stopTimer = setTimeout(() => { stop('duration'); resolveDone(0); }, durationSec * 1000);
+    const onSig = (): void => { if (stopTimer) clearTimeout(stopTimer); stop('signal'); resolveDone(0); };
+    process.on('SIGINT', onSig);
+    process.on('SIGTERM', onSig);
+
+    const code = await done;
+    process.removeListener('SIGINT', onSig);
+    process.removeListener('SIGTERM', onSig);
+    return code;
+  } catch (err: any) {
+    process.stderr.write(`[churn] FATAL: ${err && err.stack ? err.stack : err}\n`);
+    return 1;
+  }
+}
diff --git a/packages/perf-harness/src/load/harness.ts b/packages/perf-harness/src/load/harness.ts
new file mode 100644
index 0000000000..b819fa9447
--- /dev/null
+++ b/packages/perf-harness/src/load/harness.ts
@@ -0,0 +1,784 @@
+/**
+ * load/harness — workload driver for the scale-validation soak/ramp.
+ *
+ * Generates a token-bucket-paced request stream (open-loop) at a target RPS
+ * across the tenant fleet, with a read/write/meta class mix, tenant-selection
+ * shapes (zipf/uniform/burst), per-tenant auth, a cross-tenant bleed sentinel,
+ * latency histograms, rolling per-interval stdout summaries, and a final JSON
+ * report.
+ *
+ * Faithful port of `scripts/scale-validate/harness.mjs`: every flag, default,
+ * output field, protocol line, and exit code is preserved. Deviations (all
+ * mandated by DESIGN.md) are: creds resolve via `resolveCreds` with NO literal
+ * password default; the server `--port` runs through the hub guardrail; and the
+ * script becomes a `run(argv): Promise<number>` subcommand that returns exit
+ * codes (0 ok / 1 fatal / 2 bleed-sentinel violation) instead of mutating
+ * `process.exitCode` and calling `process.exit`.
+ *
+ * NO server/package code is imported — this only speaks GraphQL over HTTP.
+ */
+import fs from 'node:fs';
+
+import { Argv, asBool, asFloat, asInt } from '../core/args';
+import { assertPortAllowed, resolveCreds } from '../core/config';
+import { CANARY_PREFIX, canaryName, loadFleet, Tenant } from '../core/fleetfile';
+import {
+  buildCreateRecord, buildTypeIndex, DiscoveredOps, discoverOps, gqlErrors, gqlFetch, GqlResponse,
+  INTROSPECTION_QUERY, isRotating, isUnauthenticated, unwrapType
+} from '../core/gql';
+import { Histogram } from '../core/histogram';
+import { ensureParentDir } from '../core/proc';
+import { makeMixSampler, makeRng, makeZipfSampler } from '../core/rng';
+
+// Tiny helpers that lived inline in `_lib.mjs` and are not part of the core
+// signature surface — kept local to the load domain.
+const nowIso = (): string => new Date().toISOString();
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+const round2 = (n: number): number => Math.round(n * 100) / 100;
+
+const HELP = `perf-harness load harness — workload driver (soaks + ramps) against the running cnc server
+
+Required:
+  --fleet <file>              fleet manifest from \`fleet discover\`
+Common:
+  --port <n>                  server port (default 3333)
+  --duration-sec <n>          run length (default 60)
+  --rps <n>                   target requests/sec (default 20)
+  --mix read:.7,write:.25,meta:.05   class mix (default that)
+  --shape zipf|uniform|burst  tenant selection (default zipf)
+  --auth 0|1                  authenticate reads/writes (default 1)
+  --sentinel-interval-sec <n> bleed sentinel period (default 60)
+  --out <file>                final JSON report (default results.json)
+Tuning:
+  --report-sec <n>            rolling summary interval (default 60)
+  --burst-window-sec <n>      burst shape focus window (default 30)
+  --relogin-sec <n>           token refresh period (default 3600)
+  --timeout-ms <n>            per-request timeout (default 30000)
+  --max-inflight <n>          concurrency cap (default max(64, rps*2))
+  --rotate-backoff-ms <n>     503 retry backoff (default 250)
+  --email <addr>              seeder email (default seeder@gmail.com)
+  --password <pw>             seeder password (or PERF_PASSWORD env; required when --auth 1)
+  --seed <n>                  RNG seed for reproducible selection
+  --allow-hub                 permit a hub port for --port (danger)
+  --quiet                     suppress per-minute lines (still written to --out)
+  --help
+
+Leaked LOAD- rows (only on delete failure) are reported as write.leaked; clean
+with: DELETE FROM "<schema>".categories WHERE name LIKE 'LOAD-%';
+`;
+
+// ---------------------------------------------------------------------------
+// Auth token-field scoring (pure — exported for unit tests)
+// ---------------------------------------------------------------------------
+export function scoreTokenField(name: string): number {
+  if (/^accesstoken$/i.test(name)) return 4;
+  if (/accesstoken/i.test(name)) return 3;
+  if (/token/i.test(name)) return 2;
+  if (/jwt/i.test(name)) return 1;
+  return 0;
+}
+
+export interface TokenSelection {
+  selection: string;
+  path: string[];
+  score: number;
+}
+
+// Given a built type index and a payload type name, find the best token field to
+// select out of a signIn mutation payload. Prefers a direct scalar
+// `accessToken` (score >= 3); otherwise descends one level into object fields
+// (e.g. `result { accessToken }`).
+export function findTokenSelection(index: Map<string, any>, payloadTypeName: string): TokenSelection | null {
+  const pt = index.get(payloadTypeName);
+  if (!pt) return null;
+  let best: TokenSelection | null = null;
+  const consider = (selection: string, path: string[], score: number): void => {
+    if (score > 0 && (!best || score > best.score)) best = { selection, path, score };
+  };
+  for (const f of (pt.fields || [])) {
+    const nt = index.get(unwrapType(f.type).name);
+    if (nt && nt.kind === 'SCALAR') consider(f.name, [f.name], scoreTokenField(f.name));
+  }
+  if (best && best.score >= 3) return best;
+  for (const f of (pt.fields || [])) {
+    const nt = index.get(unwrapType(f.type).name);
+    if (nt && nt.kind === 'OBJECT') {
+      for (const sf of (nt.fields || [])) {
+        const st = index.get(unwrapType(sf.type).name);
+        if (st && st.kind === 'SCALAR') consider(`${f.name} { ${sf.name} }`, [f.name, sf.name], scoreTokenField(sf.name));
+      }
+    }
+  }
+  return best;
+}
+
+// ---------------------------------------------------------------------------
+// Startup capability fallback (pure — exported for unit tests)
+// ---------------------------------------------------------------------------
+// Used when a tenant's introspection fails: assume the canonical `categories`
+// shape so the tenant still exercises its PostGraphile instance. `queryType`/
+// `mutationType` are null because there is no schema to derive them from.
+export const DEFAULT_OPS = (): DiscoveredOps => ({
+  queryType: null,
+  mutationType: null,
+  read: 'categories',
+  meta: true,
+  create: {
+    name: 'createCategory',
+    inputTypeName: 'CreateCategoryInput',
+    innerName: 'category',
+    requiredScalars: [
+      { name: 'name', scalar: 'String', kind: 'SCALAR' },
+      { name: 'slug', scalar: 'String', kind: 'SCALAR' }
+    ],
+    payloadFieldName: 'category',
+    keySelect: 'id'
+  },
+  del: { name: 'deleteCategory', inputTypeName: 'DeleteCategoryInput', key: 'id' }
+});
+
+const isValidationAbsent = (resp: GqlResponse): boolean =>
+  gqlErrors(resp).some((e) =>
+    /cannot query field|unknown field|unknown argument|unknown type|does not exist on type|not defined|no field/i.test((e && e.message) || '')
+  );
+
+const getByPath = (obj: any, path: string[]): any => {
+  let cur = obj;
+  for (const k of path) { if (cur == null) return null; cur = cur[k]; }
+  return cur == null ? null : cur;
+};
+
+interface RuntimeTenant {
+  tenant: Tenant;
+  ops: DiscoveredOps;
+  token: string | null;
+  tokenAt: number;
+  reloginInFlight: boolean;
+  authError: string | null;
+  introspectError: string | null;
+  leakedKeys: any[];
+}
+
+interface AuthShape {
+  field: string;
+  query: string;
+  path: string[];
+  selection: string;
+}
+
+// ---------------------------------------------------------------------------
+// Subcommand entry point
+// ---------------------------------------------------------------------------
+export async function runHarness(argv: Argv): Promise<number> {
+  if (asBool(argv.help) || !argv.fleet) {
+    process.stderr.write(HELP);
+    return (!argv.fleet && !asBool(argv.help)) ? 1 : 0;
+  }
+
+  // -------------------------------------------------------------------------
+  // Config
+  // -------------------------------------------------------------------------
+  const PORT = asInt(argv.port, 3333);
+  assertPortAllowed(PORT, asBool(argv['allow-hub']), 'port');
+  const DURATION_SEC = asInt(argv['duration-sec'], 60);
+  const RPS = Math.max(asFloat(argv.rps, 20), 0.1);
+  const MIX = typeof argv.mix === 'string' ? argv.mix : 'read:0.7,write:0.25,meta:0.05';
+  const SHAPE = ['zipf', 'uniform', 'burst'].includes(argv.shape) ? argv.shape : 'zipf';
+  const AUTH = asBool(argv.auth, true);
+  const SENTINEL_SEC = asInt(argv['sentinel-interval-sec'], 60);
+  const OUT = typeof argv.out === 'string' ? argv.out : 'results.json';
+  const REPORT_SEC = asInt(argv['report-sec'], 60);
+  const BURST_WINDOW_SEC = asInt(argv['burst-window-sec'], 30);
+  const RELOGIN_SEC = asInt(argv['relogin-sec'], 3600);
+  const TIMEOUT_MS = asInt(argv['timeout-ms'], 30000);
+  const MAX_INFLIGHT = asInt(argv['max-inflight'], Math.max(64, Math.ceil(RPS * 2)));
+  const ROTATE_BACKOFF_MS = asInt(argv['rotate-backoff-ms'], 250);
+  const SEED = asInt(argv.seed, (Date.now() & 0x7fffffff));
+  const QUIET = asBool(argv.quiet);
+
+  // Credentials: NO literal password default (DESIGN creds rule). Resolve via
+  // flag > PERF_PASSWORD and fail with guidance when auth is on but absent.
+  const { email: EMAIL, password: PASSWORD } = resolveCreds(argv);
+  if (AUTH && !PASSWORD) {
+    process.stderr.write(
+      '[harness] --auth 1 but no password provided. Pass --password <pw> or set PERF_PASSWORD ' +
+        '(or run with --auth 0 to skip authentication).\n'
+    );
+    return 1;
+  }
+
+  const rng = makeRng(SEED);
+  const { tenants } = loadFleet(argv.fleet);
+
+  // -------------------------------------------------------------------------
+  // Metrics
+  // -------------------------------------------------------------------------
+  const M: any = {
+    startedAt: nowIso(),
+    config: {
+      port: PORT, durationSec: DURATION_SEC, rps: RPS, mix: MIX, shape: SHAPE, auth: AUTH,
+      sentinelIntervalSec: SENTINEL_SEC, reportSec: REPORT_SEC, burstWindowSec: BURST_WINDOW_SEC,
+      reloginSec: RELOGIN_SEC, timeoutMs: TIMEOUT_MS, maxInflight: MAX_INFLIGHT, seed: SEED,
+      fleetCount: tenants.length
+    },
+    totals: { sent: 0, completed: 0, ok: 0, err: 0, requests: 0, dropped: 0, rotating: 0, rotatingRetried: 0, timeouts: 0, network: 0 },
+    http: {},
+    netErrors: {},
+    gqlByCode: {},
+    gqlByMsg: {},
+    gqlMsgOverflow: 0,
+    classes: {
+      read: { sent: 0, ok: 0, err: 0, unavailable: 0, hist: new Histogram() },
+      write: { sent: 0, ok: 0, err: 0, unavailable: 0, fallbackRead: 0, created: 0, deleted: 0, leaked: 0, createErr: 0, deleteErr: 0, hist: new Histogram() },
+      meta: { sent: 0, ok: 0, err: 0, unavailable: 0, hist: new Histogram() }
+    },
+    overallHist: new Histogram(),
+    perTenant: {},
+    auth: { enabled: AUTH, shape: null, logins: 0, loginFailures: 0, relogins: 0, unauth: 0 },
+    sentinel: { checks: 0, tenantsChecked: 0, ownCanarySeen: 0, inconclusive: 0, violations: [], ok: true },
+    progress: []
+  };
+  for (const t of tenants) M.perTenant[t.dbname] = { sent: 0, ok: 0, err: 0 };
+
+  let windowHist = new Histogram();
+  const startMs = Date.now();
+  let pacingStartMs = 0;
+  let inFlight = 0;
+  let stopping = false;
+  let stopReason: string | null = null;
+  let exitCode = 0;
+
+  // -------------------------------------------------------------------------
+  // Runtime tenant state
+  // -------------------------------------------------------------------------
+  const runtime: RuntimeTenant[] = tenants.map((tenant): RuntimeTenant => ({
+    tenant,
+    ops: { queryType: null, mutationType: null, read: null, meta: false, create: null, del: null },
+    token: null,
+    tokenAt: 0,
+    reloginInFlight: false,
+    authError: null,
+    introspectError: null,
+    leakedKeys: []
+  }));
+
+  let writeCounter = 0;
+  const randId = (): string => `${(SEED & 0xffff).toString(36)}-${(writeCounter++).toString(36)}-${Math.floor(rng() * 1e9).toString(36)}`;
+  const log = (...a: any[]): void => { if (!QUIET) process.stderr.write(`${a.join(' ')}\n`); };
+  const emit = (obj: any): void => { process.stdout.write(`${JSON.stringify(obj)}\n`); };
+
+  // -------------------------------------------------------------------------
+  // HTTP request with retry-once on 503 SERVICE_ROTATING
+  // -------------------------------------------------------------------------
+  async function apiRequest(s: RuntimeTenant, opts: { query: string; variables?: any; token?: string }): Promise<GqlResponse> {
+    let resp = await gqlFetch({ host: s.tenant.apiHost, port: PORT, query: opts.query, variables: opts.variables, token: opts.token, timeoutMs: TIMEOUT_MS });
+    if (isRotating(resp)) {
+      M.totals.rotating++;
+      await sleep(ROTATE_BACKOFF_MS);
+      resp = await gqlFetch({ host: s.tenant.apiHost, port: PORT, query: opts.query, variables: opts.variables, token: opts.token, timeoutMs: TIMEOUT_MS });
+      M.totals.rotatingRetried++;
+    }
+    return resp;
+  }
+
+  function trackHttp(resp: GqlResponse, cls: string): void {
+    M.totals.requests++;
+    M.overallHist.record(resp.elapsedMs);
+    windowHist.record(resp.elapsedMs);
+    M.classes[cls].hist.record(resp.elapsedMs);
+    const key = String(resp.status);
+    M.http[key] = (M.http[key] || 0) + 1;
+    if (resp.error === 'timeout') M.totals.timeouts++;
+    else if (resp.error) { M.totals.network++; M.netErrors[resp.error] = (M.netErrors[resp.error] || 0) + 1; }
+    for (const e of gqlErrors(resp)) {
+      const code = (e.extensions && e.extensions.code) || 'GRAPHQL_ERROR';
+      M.gqlByCode[code] = (M.gqlByCode[code] || 0) + 1;
+      const msg = String((e && e.message) || '').slice(0, 200);
+      // Cap distinct-message cardinality so a 24h soak with id-bearing messages
+      // cannot grow this map without bound.
+      if (M.gqlByMsg[msg] !== undefined || Object.keys(M.gqlByMsg).length < 1000) {
+        M.gqlByMsg[msg] = (M.gqlByMsg[msg] || 0) + 1;
+      } else {
+        M.gqlMsgOverflow++;
+      }
+    }
+  }
+
+  function bumpTenant(s: RuntimeTenant, kind: string): void { const p = M.perTenant[s.tenant.dbname]; if (p) p[kind]++; }
+
+  function maybeRelogin(s: RuntimeTenant, resp: GqlResponse): void {
+    if (!AUTH) return;
+    if (isUnauthenticated(resp)) { M.auth.unauth++; scheduleRelogin(s); }
+  }
+
+  // -------------------------------------------------------------------------
+  // Op executors — each returns { ok } or { skip:true }; runOp folds into totals.
+  // -------------------------------------------------------------------------
+  async function execRead(s: RuntimeTenant): Promise<any> {
+    const r = M.classes.read;
+    r.sent++;
+    const resp = await apiRequest(s, { query: `{ ${s.ops.read} { totalCount nodes { name } } }`, token: s.token });
+    trackHttp(resp, 'read');
+    maybeRelogin(s, resp);
+    const ok = resp.ok && gqlErrors(resp).length === 0 && !resp.error;
+    if (ok) r.ok++; else r.err++;
+    bumpTenant(s, ok ? 'ok' : 'err');
+    return { ok };
+  }
+
+  async function execMeta(s: RuntimeTenant): Promise<any> {
+    const m = M.classes.meta;
+    m.sent++;
+    const resp = await apiRequest(s, { query: '{ _meta { tables { name } } }' });
+    trackHttp(resp, 'meta');
+    const ok = resp.ok && gqlErrors(resp).length === 0 && !resp.error;
+    if (ok) m.ok++; else m.err++;
+    bumpTenant(s, ok ? 'ok' : 'err');
+    return { ok };
+  }
+
+  function createQuery(c: any): string {
+    return `mutation Create($input: ${c.inputTypeName}!) { ${c.name}(input: $input) { ${c.payloadFieldName} { ${c.keySelect} } } }`;
+  }
+  function deleteQuery(d: any): string {
+    return `mutation Del($input: ${d.inputTypeName}!) { ${d.name}(input: $input) { clientMutationId } }`;
+  }
+
+  async function execWrite(s: RuntimeTenant): Promise<any> {
+    const w = M.classes.write;
+    w.sent++;
+    const rand = randId();
+    const record = buildCreateRecord(s.ops.create, `LOAD-${rand}`, rand);
+    const cResp = await apiRequest(s, {
+      query: createQuery(s.ops.create),
+      variables: { input: { [s.ops.create.innerName]: record } },
+      token: s.token
+    });
+    trackHttp(cResp, 'write');
+    maybeRelogin(s, cResp);
+    const cOk = cResp.ok && gqlErrors(cResp).length === 0 && !cResp.error;
+    if (!cOk) { w.createErr++; w.err++; bumpTenant(s, 'err'); return { ok: false }; }
+    w.created++;
+    const payload = cResp.json && cResp.json.data && cResp.json.data[s.ops.create.name];
+    const rec = payload && payload[s.ops.create.payloadFieldName];
+    const keyVal = rec && rec[s.ops.create.keySelect];
+    if (keyVal == null) { w.err++; w.leaked++; bumpTenant(s, 'err'); return { ok: false }; }
+    const dResp = await apiRequest(s, {
+      query: deleteQuery(s.ops.del),
+      variables: { input: { [s.ops.del.key]: keyVal } },
+      token: s.token
+    });
+    trackHttp(dResp, 'write');
+    maybeRelogin(s, dResp);
+    const dOk = dResp.ok && gqlErrors(dResp).length === 0 && !dResp.error;
+    if (dOk) { w.deleted++; w.ok++; bumpTenant(s, 'ok'); return { ok: true }; }
+    w.deleteErr++; w.leaked++; w.err++;
+    if (s.leakedKeys.length < 200) s.leakedKeys.push(keyVal);
+    bumpTenant(s, 'err');
+    return { ok: false };
+  }
+
+  // Substitution keeps a tenant's PostGraphile instance under load even when a
+  // class is unavailable for it (e.g. the blank tenant with no categories table).
+  function canWrite(s: RuntimeTenant): boolean { return !!(s.ops.create && s.ops.del && s.ops.create.payloadFieldName); }
+
+  async function opRead(s: RuntimeTenant): Promise<any> {
+    if (s.ops.read) return execRead(s);
+    M.classes.read.unavailable++;
+    if (s.ops.meta) return execMeta(s);
+    return { skip: true };
+  }
+  async function opMeta(s: RuntimeTenant): Promise<any> {
+    if (s.ops.meta) return execMeta(s);
+    M.classes.meta.unavailable++;
+    if (s.ops.read) return execRead(s);
+    return { skip: true };
+  }
+  async function opWrite(s: RuntimeTenant): Promise<any> {
+    if (canWrite(s)) return execWrite(s);
+    M.classes.write.unavailable++;
+    if (s.ops.read) { M.classes.write.fallbackRead++; return execRead(s); }
+    if (s.ops.meta) { M.classes.write.fallbackRead++; return execMeta(s); }
+    return { skip: true };
+  }
+
+  async function runOp(cls: string, s: RuntimeTenant): Promise<void> {
+    M.perTenant[s.tenant.dbname].sent++;
+    let res;
+    if (cls === 'read') res = await opRead(s);
+    else if (cls === 'write') res = await opWrite(s);
+    else res = await opMeta(s);
+    if (res && res.skip) return;
+    if (res && res.ok) M.totals.ok++; else M.totals.err++;
+  }
+
+  // -------------------------------------------------------------------------
+  // Auth
+  // -------------------------------------------------------------------------
+  async function resolveAuthShape(): Promise<AuthShape> {
+    for (const s of runtime) {
+      if (!s.tenant.authHost) continue;
+      const resp = await gqlFetch({ host: s.tenant.authHost, port: PORT, query: INTROSPECTION_QUERY, timeoutMs: TIMEOUT_MS });
+      const data = resp.json && resp.json.data;
+      if (!data || !data.__schema) continue;
+      const { index, mutationType } = buildTypeIndex(data);
+      if (!mutationType) continue;
+      const mt = index.get(mutationType);
+      const field = (mt.fields || []).find((f: any) => /^signin$/i.test(f.name)) || (mt.fields || []).find((f: any) => /signin/i.test(f.name));
+      if (!field) continue;
+      const tokenSel = findTokenSelection(index, unwrapType(field.type).name);
+      if (!tokenSel) continue;
+      const query = `mutation SignIn($email: String!, $password: String!) { ${field.name}(input: { email: $email, password: $password }) { ${tokenSel.selection} } }`;
+      return { field: field.name, query, path: [field.name, ...tokenSel.path], selection: tokenSel.selection };
+    }
+    // Fallback: documented shape.
+    return {
+      field: 'signIn',
+      query: 'mutation SignIn($email: String!, $password: String!) { signIn(input: { email: $email, password: $password }) { result { accessToken } } }',
+      path: ['signIn', 'result', 'accessToken'],
+      selection: 'result { accessToken }'
+    };
+  }
+
+  let authShape: AuthShape | null = null;
+  async function loginTenant(s: RuntimeTenant, initial: boolean): Promise<boolean> {
+    if (!authShape || !s.tenant.authHost) return false;
+    const resp = await gqlFetch({ host: s.tenant.authHost, port: PORT, query: authShape.query, variables: { email: EMAIL, password: PASSWORD }, timeoutMs: TIMEOUT_MS });
+    const errs = gqlErrors(resp);
+    if (!resp.ok || errs.length || resp.error) {
+      M.auth.loginFailures++;
+      s.authError = (errs[0] && errs[0].message) || resp.error || `http ${resp.status}`;
+      return false;
+    }
+    const tok = getByPath(resp.json && resp.json.data, authShape.path);
+    if (!tok || typeof tok !== 'string') { M.auth.loginFailures++; s.authError = 'no token in signIn response'; return false; }
+    s.token = tok;
+    s.tokenAt = Date.now();
+    s.authError = null;
+    if (initial) M.auth.logins++; else M.auth.relogins++;
+    return true;
+  }
+
+  function scheduleRelogin(s: RuntimeTenant): void {
+    if (s.reloginInFlight) return;
+    s.reloginInFlight = true;
+    loginTenant(s, false).catch(() => {}).finally(() => { s.reloginInFlight = false; });
+  }
+
+  // -------------------------------------------------------------------------
+  // Startup capability discovery (introspection + probe verification)
+  // -------------------------------------------------------------------------
+  async function resolveTenantOps(s: RuntimeTenant): Promise<void> {
+    const resp = await apiRequest(s, { query: INTROSPECTION_QUERY });
+    const data = resp.json && resp.json.data;
+    if (data && data.__schema) {
+      s.ops = discoverOps(data);
+    } else {
+      s.introspectError = (gqlErrors(resp)[0] && gqlErrors(resp)[0].message) || resp.error || `http ${resp.status}`;
+      s.ops = DEFAULT_OPS();
+    }
+    // Probe read presence (schema-level) with token so RLS doesn't mask absence.
+    if (s.ops.read) {
+      const pr = await apiRequest(s, { query: `{ ${s.ops.read} { totalCount } }`, token: s.token });
+      if (isValidationAbsent(pr)) s.ops.read = null;
+    }
+    if (s.ops.meta) {
+      const pm = await apiRequest(s, { query: '{ _meta { tables { name } } }' });
+      if (isValidationAbsent(pm)) s.ops.meta = false;
+    }
+    // Probe write: attempt a real create+delete once; downgrade only on schema absence.
+    if (canWrite(s)) {
+      const rand = `probe-${randId()}`;
+      const record = buildCreateRecord(s.ops.create, `LOAD-${rand}`, rand);
+      const cr = await apiRequest(s, { query: createQuery(s.ops.create), variables: { input: { [s.ops.create.innerName]: record } }, token: s.token });
+      if (isValidationAbsent(cr)) {
+        s.ops.create = null;
+        s.ops.del = null;
+      } else {
+        const payload = cr.json && cr.json.data && cr.json.data[s.ops.create.name];
+        const rec = payload && payload[s.ops.create.payloadFieldName];
+        const keyVal = rec && rec[s.ops.create.keySelect];
+        if (keyVal != null) {
+          await apiRequest(s, { query: deleteQuery(s.ops.del), variables: { input: { [s.ops.del.key]: keyVal } }, token: s.token });
+        }
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Bleed sentinel
+  // -------------------------------------------------------------------------
+  function pickTwo<T>(arr: T[]): T[] {
+    if (arr.length <= 1) return arr.slice();
+    const i = Math.floor(rng() * arr.length);
+    let j = Math.floor(rng() * arr.length);
+    if (j === i) j = (j + 1) % arr.length;
+    return [arr[i], arr[j]];
+  }
+
+  async function runSentinel(): Promise<void> {
+    if (stopping) return;
+    M.sentinel.checks++;
+    const eligible = runtime.filter((s) => s.ops.read && (!AUTH || s.token));
+    if (eligible.length === 0) { M.sentinel.inconclusive++; return; }
+    const picks = pickTwo(eligible);
+    for (const s of picks) {
+      M.sentinel.tenantsChecked++;
+      const resp = await apiRequest(s, { query: `{ ${s.ops.read} { nodes { name } } }`, token: s.token });
+      if (!resp.ok || gqlErrors(resp).length || resp.error) { M.sentinel.inconclusive++; continue; }
+      const nodes = (((resp.json || {}).data || {})[s.ops.read] || {}).nodes || [];
+      const own = canaryName(s.tenant);
+      let sawOwn = false;
+      for (const node of nodes) {
+        const nm = node && node.name;
+        if (typeof nm !== 'string') continue;
+        if (nm === own) { sawOwn = true; continue; }
+        if (nm.startsWith(CANARY_PREFIX)) {
+          M.sentinel.ok = false;
+          M.sentinel.violations.push({
+            at: nowIso(),
+            readTenant: s.tenant.dbname,
+            readHost: s.tenant.apiHost,
+            foreignCanary: nm,
+            sampleNames: nodes.map((n: any) => n && n.name).filter(Boolean).slice(0, 50)
+          });
+        }
+      }
+      if (sawOwn) M.sentinel.ownCanarySeen++;
+    }
+    if (!M.sentinel.ok) {
+      exitCode = 2;
+      finish('sentinel-violation');
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Pacer (token bucket) + worker pool
+  // -------------------------------------------------------------------------
+  const zipfSampler = SHAPE === 'zipf' ? makeZipfSampler(runtime.length, rng) : null;
+  let burstIndex = Math.floor(rng() * runtime.length);
+  let burstUntil = Date.now() + BURST_WINDOW_SEC * 1000;
+
+  function pickTenant(): RuntimeTenant {
+    if (SHAPE === 'uniform') return runtime[Math.floor(rng() * runtime.length)];
+    if (SHAPE === 'burst') {
+      if (Date.now() >= burstUntil) {
+        burstIndex = Math.floor(rng() * runtime.length);
+        burstUntil = Date.now() + BURST_WINDOW_SEC * 1000;
+      }
+      return runtime[burstIndex];
+    }
+    return runtime[zipfSampler()];
+  }
+
+  const mixSampler = makeMixSampler(MIX, rng);
+
+  let tokens = 0;
+  const capacity = Math.max(RPS, 1);
+  const tickMs = 20;
+  const refillPerTick = RPS * (tickMs / 1000);
+
+  function launchOne(): void {
+    inFlight++;
+    M.totals.sent++;
+    const s = pickTenant();
+    const cls = mixSampler();
+    runOp(cls, s).catch(() => {}).finally(() => {
+      inFlight--;
+      M.totals.completed++;
+      pump();
+    });
+  }
+
+  function pump(): void {
+    while (!stopping && tokens >= 1 && inFlight < MAX_INFLIGHT) {
+      tokens -= 1;
+      launchOne();
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Rolling per-interval reporter
+  // -------------------------------------------------------------------------
+  let snap = { t: startMs, completed: 0, ok: 0, err: 0 };
+  function report(kind: string): void {
+    const nowT = Date.now();
+    const elapsedSec = (nowT - startMs) / 1000;
+    const winSec = Math.max((nowT - snap.t) / 1000, 0.001);
+    const dc = M.totals.completed - snap.completed;
+    const der = M.totals.err - snap.err;
+    const line = {
+      t: kind,
+      at: nowIso(),
+      elapsedSec: round2(elapsedSec),
+      windowSec: round2(winSec),
+      sent: M.totals.sent,
+      completed: M.totals.completed,
+      ok: M.totals.ok,
+      err: M.totals.err,
+      windowRps: round2(dc / winSec),
+      cumRps: round2(M.totals.completed / Math.max(elapsedSec, 0.001)),
+      windowErrRate: dc ? round2(der / dc) : 0,
+      inFlight,
+      dropped: Math.round(M.totals.dropped),
+      rotating: M.totals.rotating,
+      latencyWindow: windowHist.summary(),
+      sentinelChecks: M.sentinel.checks,
+      sentinelOwnSeen: M.sentinel.ownCanarySeen,
+      sentinelOk: M.sentinel.ok
+    };
+    emit(line);
+    M.progress.push(line);
+    snap = { t: nowT, completed: M.totals.completed, ok: M.totals.ok, err: M.totals.err };
+    windowHist = new Histogram();
+  }
+
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  let timers: any[] = [];
+  let durationTimer: any = null;
+  let donePromiseResolve: (value?: void | PromiseLike<void>) => void;
+  const donePromise = new Promise<void>((res) => { donePromiseResolve = res; });
+
+  function finish(reason: string): void {
+    if (stopping) return;
+    stopping = true;
+    stopReason = reason;
+    for (const t of timers) clearInterval(t);
+    timers = [];
+    if (durationTimer) { clearTimeout(durationTimer); durationTimer = null; }
+    donePromiseResolve();
+  }
+
+  async function drain(): Promise<void> {
+    const deadline = Date.now() + 15000;
+    while (inFlight > 0 && Date.now() < deadline) await sleep(50);
+  }
+
+  function finalize(): any {
+    const endMs = Date.now();
+    const wallSec = (endMs - startMs) / 1000;
+    const loadSec = (endMs - (pacingStartMs || startMs)) / 1000;
+    const topN = (obj: any, n = 20): any[] => Object.entries(obj).sort((a: any, b: any) => b[1] - a[1]).slice(0, n).map(([k, v]) => ({ key: k, count: v }));
+    const classSummary = (c: any): any => {
+      const base = { sent: c.sent, ok: c.ok, err: c.err, unavailable: c.unavailable, latency: c.hist.summary() };
+      if (c === M.classes.write) {
+        return { ...base, created: c.created, deleted: c.deleted, leaked: c.leaked, createErr: c.createErr, deleteErr: c.deleteErr, fallbackRead: c.fallbackRead };
+      }
+      return base;
+    };
+    const out = {
+      startedAt: M.startedAt,
+      endedAt: nowIso(),
+      wallSec: round2(wallSec),
+      loadSec: round2(loadSec),
+      stopReason,
+      config: M.config,
+      fleet: { count: tenants.length, file: argv.fleet },
+      capabilities: runtime.map((s) => ({
+        dbname: s.tenant.dbname,
+        apiHost: s.tenant.apiHost,
+        read: !!s.ops.read,
+        write: canWrite(s),
+        meta: !!s.ops.meta,
+        authed: !!s.token,
+        authError: s.authError,
+        introspectError: s.introspectError,
+        leakedKeys: s.leakedKeys.length
+      })),
+      totals: {
+        ...M.totals,
+        dropped: Math.round(M.totals.dropped),
+        achievedRps: round2(M.totals.completed / Math.max(loadSec, 0.001)),
+        errRate: M.totals.completed ? round2(M.totals.err / M.totals.completed) : 0
+      },
+      latencyOverall: M.overallHist.summary(),
+      byClass: { read: classSummary(M.classes.read), write: classSummary(M.classes.write), meta: classSummary(M.classes.meta) },
+      http: M.http,
+      netErrors: M.netErrors,
+      gqlErrorsByCode: M.gqlByCode,
+      gqlErrorsTop: topN(M.gqlByMsg),
+      gqlErrorsMsgOverflow: M.gqlMsgOverflow,
+      perTenant: M.perTenant,
+      auth: M.auth,
+      sentinel: M.sentinel,
+      progress: M.progress,
+      verdict: {
+        pass: M.sentinel.ok,
+        bleedViolations: M.sentinel.violations.length,
+        note: M.sentinel.ok ? 'no cross-tenant bleed detected' : 'BLEED SENTINEL VIOLATION'
+      }
+    };
+    ensureParentDir(OUT);
+    fs.writeFileSync(OUT, `${JSON.stringify(out, null, 2)}\n`);
+    return out;
+  }
+
+  // -------------------------------------------------------------------------
+  // Main
+  // -------------------------------------------------------------------------
+  const onSig = (): void => finish('signal');
+  const cleanup = (): void => {
+    for (const t of timers) clearInterval(t);
+    timers = [];
+    if (durationTimer) { clearTimeout(durationTimer); durationTimer = null; }
+    process.removeListener('SIGINT', onSig);
+    process.removeListener('SIGTERM', onSig);
+  };
+
+  try {
+    log(`[harness] seed=${SEED} shape=${SHAPE} rps=${RPS} dur=${DURATION_SEC}s mix=${MIX} auth=${AUTH} tenants=${tenants.length} -> ${OUT}`);
+
+    if (AUTH) {
+      authShape = await resolveAuthShape();
+      M.auth.shape = authShape.selection;
+      log(`[harness] auth shape: ${authShape.field} { ${authShape.selection} }`);
+      await Promise.all(runtime.map((s) => loginTenant(s, true)));
+      log(`[harness] logins ok=${M.auth.logins} failed=${M.auth.loginFailures}`);
+    }
+
+    await Promise.all(runtime.map((s) => resolveTenantOps(s).catch((e) => { s.introspectError = String((e && e.message) || e); })));
+    const caps = runtime.map((s) => `${s.tenant.dbname.replace('marketplace_db_', '')}[r=${s.ops.read ? 1 : 0}w=${canWrite(s) ? 1 : 0}m=${s.ops.meta ? 1 : 0}${s.token ? 'a' : ''}]`);
+    log(`[harness] capabilities: ${caps.join(' ')}`);
+
+    // Timers
+    pacingStartMs = Date.now();
+    snap = { t: pacingStartMs, completed: 0, ok: 0, err: 0 };
+    timers.push(setInterval(() => {
+      if (stopping) return;
+      tokens += refillPerTick;
+      if (tokens > capacity) { M.totals.dropped += (tokens - capacity); tokens = capacity; }
+      pump();
+    }, tickMs));
+    timers.push(setInterval(() => report('progress'), REPORT_SEC * 1000));
+    timers.push(setInterval(() => { runSentinel().catch(() => {}); }, SENTINEL_SEC * 1000));
+    timers.push(setInterval(() => {
+      if (!AUTH) return;
+      const cutoff = Date.now() - RELOGIN_SEC * 1000;
+      for (const s of runtime) if (s.token && s.tokenAt < cutoff) scheduleRelogin(s);
+    }, 30000));
+
+    durationTimer = setTimeout(() => finish('duration'), DURATION_SEC * 1000);
+    process.on('SIGINT', onSig);
+    process.on('SIGTERM', onSig);
+
+    await donePromise;
+    await drain();
+    const out = finalize();
+
+    const c = out.byClass;
+    log(`[harness] DONE reason=${stopReason} wall=${out.wallSec}s load=${out.loadSec}s completed=${out.totals.completed} ok=${out.totals.ok} err=${out.totals.err} achievedRps=${out.totals.achievedRps} p50=${out.latencyOverall.p50} p95=${out.latencyOverall.p95} p99=${out.latencyOverall.p99}`);
+    log(`[harness] read ${c.read.ok}/${c.read.err} write ${c.write.ok}/${c.write.err}(created=${c.write.created} leaked=${c.write.leaked}) meta ${c.meta.ok}/${c.meta.err} | sentinel checks=${M.sentinel.checks} ownSeen=${M.sentinel.ownCanarySeen} violations=${M.sentinel.violations.length}`);
+    log(`[harness] wrote ${OUT}`);
+    if (!M.sentinel.ok) log('[harness] *** BLEED SENTINEL VIOLATION — exit 2 ***');
+
+    cleanup();
+    return exitCode;
+  } catch (err: any) {
+    process.stderr.write(`[harness] FATAL: ${err && err.stack ? err.stack : err}\n`);
+    try { finalize(); } catch { /* best effort */ }
+    cleanup();
+    return exitCode || 1;
+  }
+}
diff --git a/packages/perf-harness/src/measure/__tests__/collector.test.ts b/packages/perf-harness/src/measure/__tests__/collector.test.ts
new file mode 100644
index 0000000000..ba3819bd1a
--- /dev/null
+++ b/packages/perf-harness/src/measure/__tests__/collector.test.ts
@@ -0,0 +1,115 @@
+import { flattenNumeric, linregSlope, pickCounter } from '../collector';
+
+describe('linregSlope', () => {
+  test('perfect line through the origin recovers the slope', () => {
+    expect(linregSlope([[0, 0], [1, 2], [2, 4], [3, 6]])).toBeCloseTo(2, 10);
+  });
+
+  test('fractional slope', () => {
+    expect(linregSlope([[0, 1], [2, 2]])).toBeCloseTo(0.5, 10);
+  });
+
+  test('flat series has zero slope', () => {
+    expect(linregSlope([[0, 5], [1, 5], [2, 5]])).toBe(0);
+  });
+
+  test('fewer than two points returns 0', () => {
+    expect(linregSlope([])).toBe(0);
+    expect(linregSlope([[3, 3]])).toBe(0);
+  });
+
+  test('degenerate x (zero denominator) returns 0', () => {
+    expect(linregSlope([[5, 1], [5, 9]])).toBe(0);
+  });
+
+  test('last-half behavior: slope tracks only the recent (second-half) trend', () => {
+    // First half flat at 500, second half rising +10 MB/sec. finalize() regresses
+    // over samples.slice(floor(len/2)) — the last half — so the reported slope is
+    // the recent trend, not the whole-run average.
+    const samples = [
+      { tSec: 0, rssMb: 500 },
+      { tSec: 1, rssMb: 500 },
+      { tSec: 2, rssMb: 500 },
+      { tSec: 3, rssMb: 500 },
+      { tSec: 4, rssMb: 500 },
+      { tSec: 5, rssMb: 510 },
+      { tSec: 6, rssMb: 520 },
+      { tSec: 7, rssMb: 530 }
+    ];
+    const full = linregSlope(samples.map((s) => [s.tSec, s.rssMb]));
+    const lastHalf = samples.slice(Math.floor(samples.length / 2));
+    const halfSlope = linregSlope(lastHalf.map((s) => [s.tSec, s.rssMb]));
+
+    expect(halfSlope).toBeCloseTo(10, 10); // MB/sec over the last half only
+    expect(full).toBeGreaterThan(0);
+    expect(full).toBeLessThan(halfSlope); // whole-run average is diluted by the flat first half
+
+    // and the MB/hour conversion finalize() applies
+    const slopeMbPerHour = Math.round(halfSlope * 3600 * 100) / 100;
+    expect(slopeMbPerHour).toBe(36000);
+  });
+});
+
+// A representative server metrics line (schema owned by the server
+// instrumentation; the tailer must stay schema-tolerant).
+const METRICS_LINE = {
+  ts: '2026-07-03T00:00:00.000Z',
+  heapUsed: 123456789,
+  rss: 234567890,
+  cache: { size: 2, max: 64 },
+  counters: {
+    evictions: { total: 12, lru: 8, ttl: 4 },
+    drains: 3,
+    builds: 7,
+    connGuard: { blocked: 0 }
+  }
+};
+
+describe('flattenNumeric', () => {
+  const flat = flattenNumeric(METRICS_LINE);
+  const byPath = Object.fromEntries(flat.map((f) => [f.path, f.value]));
+
+  test('flattens nested numeric leaves with dotted paths', () => {
+    expect(byPath['heapUsed']).toBe(123456789);
+    expect(byPath['rss']).toBe(234567890);
+    expect(byPath['cache.size']).toBe(2);
+    expect(byPath['cache.max']).toBe(64);
+    expect(byPath['counters.evictions.total']).toBe(12);
+    expect(byPath['counters.evictions.lru']).toBe(8);
+    expect(byPath['counters.builds']).toBe(7);
+    expect(byPath['counters.connGuard.blocked']).toBe(0);
+  });
+
+  test('excludes non-numeric fields', () => {
+    expect(byPath['ts']).toBeUndefined();
+    expect(flat.every((f) => typeof f.value === 'number')).toBe(true);
+  });
+});
+
+describe('pickCounter', () => {
+  const flat = flattenNumeric(METRICS_LINE);
+
+  test('prefers an explicit total over sibling numeric fields', () => {
+    const evict = pickCounter(flat, 'evict');
+    expect(evict.value).toBe(12);
+    expect(evict.path).toBe('counters.evictions.total');
+    expect(evict.candidates).toHaveLength(3); // total + lru + ttl
+  });
+
+  test('picks a lone scalar counter', () => {
+    const build = pickCounter(flat, 'build');
+    expect(build.value).toBe(7);
+    expect(build.path).toBe('counters.builds');
+
+    const drain = pickCounter(flat, 'drain');
+    expect(drain.value).toBe(3);
+    expect(drain.path).toBe('counters.drains');
+  });
+
+  test('no match yields a null pick with no candidates', () => {
+    const none = pickCounter(flat, 'zzz-nope');
+    expect(none.value).toBeNull();
+    expect(none.path).toBeNull();
+    expect(none.candidates).toEqual([]);
+  });
+});
diff --git a/packages/perf-harness/src/measure/__tests__/pgSampler.test.ts b/packages/perf-harness/src/measure/__tests__/pgSampler.test.ts
new file mode 100644
index 0000000000..0a8eb16015
--- /dev/null
+++ b/packages/perf-harness/src/measure/__tests__/pgSampler.test.ts
@@ -0,0 +1,35 @@
+import { toBytes } from '../pgSampler';
+
+describe('toBytes (docker MemUsage unit parser)', () => {
+  test('bytes', () => {
+    expect(toBytes('512B')).toBe(512);
+  });
+
+  test('KiB', () => {
+    expect(toBytes('2KiB')).toBe(2048);
+  });
+
+  test('MiB', () => {
+    expect(toBytes('1.5MiB')).toBe(1572864); // 1.5 * 1024^2
+  });
+
+  test('GiB', () => {
+    expect(toBytes('4GiB')).toBe(4294967296); // 4 * 1024^3
+    expect(toBytes('1.234GiB')).toBe(Math.round(1.234 * 1024 ** 3));
+  });
+
+  test('tolerates whitespace between value and unit', () => {
+    expect(toBytes('1.234 GiB')).toBe(Math.round(1.234 * 1024 ** 3));
+  });
+
+  test('parses each side of a docker "used / limit" string', () => {
+    const [used, limit] = '1.234GiB / 4GiB'.split('/').map((s) => toBytes(s));
+    expect(used).toBe(Math.round(1.234 * 1024 ** 3));
+    expect(limit).toBe(4294967296);
+  });
+
+  test('unknown / unparseable input returns null', () => {
+    expect(toBytes('nonsense')).toBeNull();
+    expect(toBytes('')).toBeNull();
+  });
+});
diff --git a/packages/perf-harness/src/measure/collector.ts b/packages/perf-harness/src/measure/collector.ts
new file mode 100644
index 0000000000..99e800cbcb
--- /dev/null
+++ b/packages/perf-harness/src/measure/collector.ts
@@ -0,0 +1,266 @@
+/**
+ * collector — RSS sampler + server metrics tailer.
+ *
+ * Port of `scripts/scale-validate/collector.mjs`. Samples the server process RSS
+ * (`ps -o rss=`) every --interval-sec and tails the server's metrics JSONL. At
+ * exit it computes:
+ *   - RSS min / max / final (MB)
+ *   - linear-regression slope (MB/hour) over the LAST HALF of the RSS samples
+ *   - eviction / drain / build totals parsed from the LAST metrics line
+ * and writes a summary JSON to --out.
+ *
+ * The metrics JSONL schema is owned by the server instrumentation; this tailer
+ * is intentionally schema-tolerant: it flattens the last JSON object and picks
+ * the best numeric field per counter family (evict / drain / build).
+ *
+ * Exit is triggered by SIGINT/SIGTERM, by --duration-sec, or when the monitored
+ * PID disappears. The JSONL protocol lines are written to stdout (machine
+ * readable); the summary file goes to --out.
+ */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+
+import { Argv, asInt, usageExit } from '../core/args';
+import { ensureParentDir } from '../core/proc';
+
+// Tiny helpers the standalone script imported from _lib.mjs; core does not
+// re-export them (histogram folded round2 in privately), so inline them here
+// exactly as the original defined them.
+const nowIso = (): string => new Date().toISOString();
+const round2 = (n: number): number => Math.round(n * 100) / 100;
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+const HELP = `measure collector — sample RSS + tail metrics.jsonl, summarize at exit
+
+Options:
+  --pid <n>            server process id to sample (required)
+  --metrics-file <f>   server metrics.jsonl to tail (optional)
+  --interval-sec <n>   sample period (default 15)
+  --duration-sec <n>   run length (default 0 = until SIGINT or pid exit)
+  --out <file>         summary JSON (default collector.json)
+  --help
+`;
+
+export interface FlatNumeric {
+  path: string;
+  value: number;
+}
+
+export interface CounterCandidate {
+  path: string;
+  value: number;
+}
+
+export interface CounterPick {
+  value: number | null;
+  path: string | null;
+  candidates: CounterCandidate[];
+}
+
+function sampleRssMb(pid: number): number | null {
+  const res = spawnSync('ps', ['-o', 'rss=', '-p', String(pid)], { encoding: 'utf8' });
+  if (res.status !== 0) return null;
+  const kb = Number.parseInt((res.stdout || '').trim(), 10);
+  if (!Number.isFinite(kb)) return null;
+  return round2(kb / 1024);
+}
+
+// Least-squares slope of y over x. Returns slope in y-units per x-unit.
+export function linregSlope(points: number[][]): number {
+  const n = points.length;
+  if (n < 2) return 0;
+  let sx = 0;
+  let sy = 0;
+  let sxx = 0;
+  let sxy = 0;
+  for (const [x, y] of points) {
+    sx += x;
+    sy += y;
+    sxx += x * x;
+    sxy += x * y;
+  }
+  const denom = n * sxx - sx * sx;
+  if (denom === 0) return 0;
+  return (n * sxy - sx * sy) / denom;
+}
+
+// Flatten nested object into [{ path, value }] for numeric leaves only.
+export function flattenNumeric(obj: any, prefix = '', out: FlatNumeric[] = []): FlatNumeric[] {
+  if (obj == null || typeof obj !== 'object') return out;
+  for (const [k, v] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${k}` : k;
+    if (typeof v === 'number' && Number.isFinite(v)) out.push({ path, value: v });
+    else if (v && typeof v === 'object') flattenNumeric(v, path, out);
+  }
+  return out;
+}
+
+// Pick the best-matching numeric field for a counter family.
+export function pickCounter(flat: FlatNumeric[], family: string): CounterPick {
+  const re = new RegExp(family, 'i');
+  const candidates = flat.filter((f) => re.test(f.path));
+  if (candidates.length === 0) return { value: null, path: null, candidates: [] };
+  // Prefer explicit totals/counts, then longer (more specific) paths.
+  const score = (p: string): number => (/(total|count|sum|cumulative|s$)/i.test(p) ? 2 : 0) + p.length / 1000;
+  candidates.sort((a, b) => score(b.path) - score(a.path));
+  return {
+    value: candidates[0].value,
+    path: candidates[0].path,
+    candidates: candidates.map((c) => ({ path: c.path, value: c.value }))
+  };
+}
+
+export async function runCollector(argv: Argv): Promise<number> {
+  if (argv.help) return usageExit(HELP, 0);
+  if (argv.pid === undefined) return usageExit(HELP, 1);
+
+  const pid = asInt(argv.pid, 0);
+  const metricsFile = typeof argv['metrics-file'] === 'string' ? argv['metrics-file'] : null;
+  const intervalSec = asInt(argv['interval-sec'], 15);
+  const durationSec = asInt(argv['duration-sec'], 0);
+  const out = typeof argv.out === 'string' ? argv.out : 'collector.json';
+
+  const startMs = Date.now();
+  const samples: { tSec: number; rssMb: number }[] = [];
+  let lastMetricsObj: any = null;
+  let metricsLinesSeen = 0;
+  let metricsOffset = 0;
+  let stopping = false;
+  let stopReason: string | null = null;
+
+  const readMetricsTail = (): void => {
+    if (!metricsFile) return;
+    let stat;
+    try {
+      stat = fs.statSync(metricsFile);
+    } catch {
+      return;
+    }
+    if (stat.size < metricsOffset) metricsOffset = 0; // rotated/truncated
+    if (stat.size === metricsOffset) return;
+    let chunk = '';
+    try {
+      const fd = fs.openSync(metricsFile, 'r');
+      const len = stat.size - metricsOffset;
+      const buf = Buffer.alloc(len);
+      fs.readSync(fd, buf, 0, len, metricsOffset);
+      fs.closeSync(fd);
+      chunk = buf.toString('utf8');
+      metricsOffset = stat.size;
+    } catch {
+      return;
+    }
+    for (const line of chunk.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      metricsLinesSeen++;
+      try {
+        lastMetricsObj = JSON.parse(trimmed);
+      } catch {
+        /* partial/non-json line — ignore */
+      }
+    }
+  };
+
+  const emit = (obj: any): void => {
+    process.stdout.write(`${JSON.stringify({ at: nowIso(), ...obj })}\n`);
+  };
+  emit({ t: 'start', pid, metricsFile, intervalSec, durationSec });
+
+  const finalize = (): any => {
+    const rssValues = samples.map((s) => s.rssMb);
+    const rssMin = rssValues.length ? Math.min(...rssValues) : null;
+    const rssMax = rssValues.length ? Math.max(...rssValues) : null;
+    const rssFinal = rssValues.length ? rssValues[rssValues.length - 1] : null;
+    // slope over the last half of samples
+    const half = samples.slice(Math.floor(samples.length / 2));
+    const slopeMbPerSec = linregSlope(half.map((s) => [s.tSec, s.rssMb]));
+    const slopeMbPerHour = round2(slopeMbPerSec * 3600);
+
+    const flat = lastMetricsObj ? flattenNumeric(lastMetricsObj) : [];
+    const evictions = pickCounter(flat, 'evict');
+    const drains = pickCounter(flat, 'drain');
+    const builds = pickCounter(flat, 'build');
+
+    const summary = {
+      generatedAt: nowIso(),
+      pid,
+      stopReason,
+      durationSec: round2((Date.now() - startMs) / 1000),
+      intervalSec,
+      rss: {
+        samples: samples.length,
+        minMb: rssMin,
+        maxMb: rssMax,
+        finalMb: rssFinal,
+        slopeMbPerHour,
+        slopeBasis: `last ${half.length} of ${samples.length} samples`,
+        series: samples
+      },
+      metrics: {
+        file: metricsFile,
+        linesSeen: metricsLinesSeen,
+        evictionsTotal: evictions.value,
+        evictionsField: evictions.path,
+        drainsTotal: drains.value,
+        drainsField: drains.path,
+        buildsTotal: builds.value,
+        buildsField: builds.path,
+        candidates: { evict: evictions.candidates, drain: drains.candidates, build: builds.candidates },
+        lastLine: lastMetricsObj
+      }
+    };
+    ensureParentDir(out);
+    fs.writeFileSync(out, `${JSON.stringify(summary, null, 2)}\n`);
+    emit({
+      t: 'summary',
+      rssMinMb: rssMin,
+      rssMaxMb: rssMax,
+      rssFinalMb: rssFinal,
+      slopeMbPerHour,
+      evictionsTotal: evictions.value,
+      drainsTotal: drains.value,
+      buildsTotal: builds.value,
+      out
+    });
+    return summary;
+  };
+
+  const onSig = (): void => {
+    stopping = true;
+    stopReason = stopReason || 'signal';
+  };
+  process.on('SIGINT', onSig);
+  process.on('SIGTERM', onSig);
+
+  try {
+    // Prime the metrics offset so we start reading from current EOF-ish but
+    // still capture the last line: read everything once so lastMetricsObj is
+    // populated.
+    readMetricsTail();
+
+    while (!stopping) {
+      const rssMb = sampleRssMb(pid);
+      if (rssMb == null) {
+        stopReason = 'pid-exited';
+        break;
+      }
+      samples.push({ tSec: round2((Date.now() - startMs) / 1000), rssMb });
+      readMetricsTail();
+      emit({ t: 'sample', tSec: round2((Date.now() - startMs) / 1000), rssMb, metricsLines: metricsLinesSeen });
+      if (durationSec > 0 && (Date.now() - startMs) / 1000 >= durationSec) {
+        stopReason = 'duration';
+        break;
+      }
+      // sleep in small slices so SIGINT is responsive
+      const until = Date.now() + intervalSec * 1000;
+      while (!stopping && Date.now() < until) await sleep(200);
+    }
+    readMetricsTail();
+    finalize();
+    return 0;
+  } catch (err: any) {
+    process.stderr.write(`[collector] FATAL: ${err && err.stack ? err.stack : err}\n`);
+    return 1;
+  }
+}
diff --git a/packages/perf-harness/src/measure/instanceHeap.ts b/packages/perf-harness/src/measure/instanceHeap.ts
new file mode 100644
index 0000000000..d611439102
--- /dev/null
+++ b/packages/perf-harness/src/measure/instanceHeap.ts
@@ -0,0 +1,206 @@
+/**
+ * instanceHeap — per-class instance heap cost (V2 sizing input).
+ *
+ * Port of `scripts/scale-validate/measure-instance-heap.mjs`. Boots a FRESH
+ * server (own child process, own metrics file) via run/server.ts `spawnServer`
+ * with the blueprint cache capped at 1, waits for the metrics sampler baseline,
+ * cold-builds exactly ONE instance class by hitting a single virtual host, lets
+ * the heap settle, and records the delta. Because the server is fresh and only
+ * one host is ever hit, the delta IS the marginal cost of the first resident
+ * instance of that class (instance + its share of lazily initialized caches).
+ *
+ * Env: PGHOST/PGPORT/PGUSER/PGPASSWORD/PGDATABASE (or --pg-* flags; PG port
+ * defaults to 5433, never 5432). The server port + PG port both run through the
+ * hub-safety guardrail.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv, asBool, asInt, usageExit } from '../core/args';
+import {
+  assertPortAllowed,
+  findRepoRoot,
+  PgConfig,
+  pgConfigFromArgv,
+  resolveOutDir,
+  resolveServerCmd
+} from '../core/config';
+import { ensureParentDir, readJsonl } from '../core/proc';
+import { spawnServer, SpawnedServer } from '../run/server';
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+const MB = (b: number): number => Math.round((b / 1024 / 1024) * 10) / 10;
+
+const USAGE = `measure instance-heap — marginal per-class heap cost on a fresh cap=1 server
+
+Options:
+  --label <name>       label for artifacts + result row (default unlabeled)
+  --host <vhost>       virtual host to cold-build (required, e.g. api-xxx.localhost)
+  --port <n>           server port (default 3344)
+  --heap-mb <n>        --max-old-space-size for the child (default 2048)
+  --cache-max <n>      GRAPHILE_CACHE_MAX for the child (default 1)
+  --settle-sec <n>     settle window after the cold build (default 70)
+  --out <file>         result JSONL (default <out-dir>/instance-heap-results.jsonl)
+  --out-dir <dir>      artifact directory (default ./perf-out)
+  --server-cmd <cmd>   override the server launch command (whitespace-split)
+  --pg-host/--pg-port/--pg-user/--pg-password/--pg-database   connection overrides
+  --allow-hub          permit a reserved constructive-hub port (danger)
+  --help
+`;
+
+// Probe a virtual host with a `{ __typename }` query. Kept local (not gqlFetch)
+// so the recorded { status, ms, body } shape matches the original exactly.
+async function probeTypename(
+  host: string,
+  port: number,
+  timeoutMs: number
+): Promise<{ status: number; ms: number; body: string }> {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  const start = performance.now();
+  try {
+    const res = await fetch(`http://${host}:${port}/graphql`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', accept: 'application/json' },
+      body: JSON.stringify({ query: 'query { __typename }' }),
+      signal: ac.signal
+    });
+    const body = await res.text();
+    return { status: res.status, ms: Math.round(performance.now() - start), body: body.slice(0, 200) };
+  } catch (e) {
+    return { status: 0, ms: Math.round(performance.now() - start), body: String(e).slice(0, 200) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function runInstanceHeap(argv: Argv): Promise<number> {
+  if (argv.help) return usageExit(USAGE, 0);
+
+  const label = typeof argv.label === 'string' ? argv.label : 'unlabeled';
+  const host = typeof argv.host === 'string' ? argv.host : null;
+  const port = asInt(argv.port, 3344);
+  const heapMb = asInt(argv['heap-mb'], 2048);
+  // Keep the raw string for the result field (original stored the string '1');
+  // pass a number to spawnServer.
+  const cacheMaxRaw = typeof argv['cache-max'] === 'string' ? argv['cache-max'] : '1';
+  const cacheMax = asInt(cacheMaxRaw, 1);
+  const settleSec = asInt(argv['settle-sec'], 70);
+  if (!host) return usageExit('--host is required', 1);
+
+  const allowHub = asBool(argv['allow-hub']);
+  let pg: PgConfig;
+  try {
+    pg = pgConfigFromArgv(argv); // hub guardrail on the PG port
+    assertPortAllowed(port, allowHub, 'server-port'); // hub guardrail on the server port
+  } catch (e: any) {
+    console.error(`[${label}] ${e && e.message ? e.message : e}`);
+    return 1;
+  }
+
+  const outDir = resolveOutDir(argv);
+  const repoRoot = findRepoRoot();
+  const serverCmd = resolveServerCmd(argv, repoRoot);
+  const serverName = `cap1-${label}`;
+  const metricsFile = path.join(outDir, `metrics-${serverName}.jsonl`);
+  const out = typeof argv.out === 'string' ? argv.out : path.join(outDir, 'instance-heap-results.jsonl');
+  if (fs.existsSync(metricsFile)) fs.rmSync(metricsFile);
+
+  const readMetrics = (): any[] => readJsonl(metricsFile);
+
+  console.error(`[${label}] starting server port=${port} heap=${heapMb}MB cacheMax=${cacheMaxRaw} host=${host}`);
+  const result: any = { label, host, heapMb, cacheMax: cacheMaxRaw, ok: false };
+  let server: SpawnedServer | null = null;
+  try {
+    server = await spawnServer({
+      name: serverName,
+      port,
+      heapMb,
+      metricsFile,
+      pg,
+      repoRoot,
+      outDir,
+      serverCmd,
+      cacheMax,
+      allowHub
+    });
+    console.error(`[${label}] listening; waiting for baseline metrics...`);
+
+    // Baseline: at least 2 sampler lines (~20s) so init transients are past.
+    let m: any[] = [];
+    const baseDeadline = Date.now() + 90000;
+    while (Date.now() < baseDeadline) {
+      m = readMetrics();
+      if (m.length >= 2) break;
+      await sleep(2000);
+    }
+    if (m.length < 2) throw new Error(`no metrics baseline (${m.length} lines): sampler not writing?`);
+    const baseline = m[m.length - 1];
+    const baselineCount = m.length;
+    result.baseline = { heapUsedMB: MB(baseline.heapUsed), rssMB: MB(baseline.rss) };
+    console.error(`[${label}] baseline heapUsed=${result.baseline.heapUsedMB}MB rss=${result.baseline.rssMB}MB`);
+
+    // Cold build: first request to this host builds the instance.
+    const cold = await probeTypename(host, port, 420000);
+    result.cold = cold;
+    console.error(`[${label}] cold request: status=${cold.status} ${cold.ms}ms ${cold.body}`);
+    if (cold.status !== 200) throw new Error(`cold request failed: ${cold.status} ${cold.body}`);
+
+    // Settle and sample.
+    const targetLines = baselineCount + Math.ceil(settleSec / 10);
+    const settleDeadline = Date.now() + settleSec * 1000 + 60000;
+    while (Date.now() < settleDeadline) {
+      m = readMetrics();
+      if (m.length >= targetLines) break;
+      await sleep(5000);
+    }
+    const post = m.slice(baselineCount);
+    if (post.length === 0) throw new Error('no post-build metrics samples');
+    const last = post[post.length - 1];
+    const heaps = post.map((x: any) => x.heapUsed);
+    const rsss = post.map((x: any) => x.rss);
+    result.postBuild = {
+      samples: post.length,
+      heapUsedLastMB: MB(last.heapUsed),
+      heapUsedMinMB: MB(Math.min(...heaps)),
+      heapUsedMaxMB: MB(Math.max(...heaps)),
+      rssLastMB: MB(last.rss),
+      rssMaxMB: MB(Math.max(...rsss)),
+      cache: last.cache,
+      counters: last.counters
+    };
+    result.deltaHeapMB = Math.round((result.postBuild.heapUsedLastMB - result.baseline.heapUsedMB) * 10) / 10;
+    result.deltaRssMB = Math.round((result.postBuild.rssLastMB - result.baseline.rssMB) * 10) / 10;
+
+    // Warm request: instance resident, should be fast.
+    const warm = await probeTypename(host, port, 30000);
+    result.warm = { status: warm.status, ms: warm.ms };
+    result.ok = warm.status === 200;
+    console.error(
+      `[${label}] deltaHeap=${result.deltaHeapMB}MB deltaRss=${result.deltaRssMB}MB ` +
+        `(post last=${result.postBuild.heapUsedLastMB}MB min=${result.postBuild.heapUsedMinMB}MB ` +
+        `max=${result.postBuild.heapUsedMaxMB}MB) warm=${warm.ms}ms`
+    );
+  } catch (e: any) {
+    // A startup (port-wait) timeout throws before `server` is assigned, but
+    // spawnServer attaches the started child to err.server so we can still tail
+    // its log and stop it in the finally.
+    if (!server && e && e.server) server = e.server;
+    result.error = String(e && e.message ? e.message : e);
+    result.serverLogTail = server ? server.logTail(1500) : '';
+    console.error(`[${label}] FAILED: ${result.error}`);
+  } finally {
+    if (server) {
+      try {
+        await server.stop();
+      } catch {
+        /* already gone */
+      }
+    }
+  }
+
+  ensureParentDir(out);
+  fs.appendFileSync(out, JSON.stringify(result) + '\n');
+  console.error(`[${label}] result appended to ${out}`);
+  return result.ok ? 0 : 1;
+}
diff --git a/packages/perf-harness/src/measure/pgSampler.ts b/packages/perf-harness/src/measure/pgSampler.ts
new file mode 100644
index 0000000000..1b6a0b826c
--- /dev/null
+++ b/packages/perf-harness/src/measure/pgSampler.ts
@@ -0,0 +1,146 @@
+/**
+ * pgSampler — PG-side time series for perf runs.
+ *
+ * Port of `scripts/scale-validate/pg-sampler.mjs`. The node side is covered by
+ * the server's GRAPHILE_DEBUG_METRICS JSONL; this captures the Postgres half.
+ *
+ * Every --interval-sec appends one JSONL line to --out with:
+ *   - docker container memory (usage/limit bytes) for --container
+ *   - pg_stat_activity backend counts by state (+ total)
+ *   - pg_class row count (catalog size proxy) and current database size
+ *
+ * Connection: standard PG* env vars (or --pg-* flags via pgConfigFromArgv, which
+ * also runs the hub-port guardrail). A FRESH client per sample (the rig runs
+ * idle_session_timeout=120s; a persistent idle client would be reaped mid-run).
+ * Sampling errors are recorded on the line ({err}) and never kill the sampler —
+ * a PG crash/recovery window is exactly the data we want to keep collecting
+ * through.
+ *
+ * Exit: --duration-sec elapsed, or SIGINT/SIGTERM (JSONL is append-per-line,
+ * nothing to flush).
+ */
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv, asInt, usageExit } from '../core/args';
+import { PgConfig, pgConfigFromArgv } from '../core/config';
+import { withFreshClient } from '../core/pgc';
+
+const nowIso = (): string => new Date().toISOString();
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+const USAGE = `measure pg — docker + pg_stat_activity/pg_class/db-size sampler
+
+Options:
+  --out <file>         JSONL output (default out/pg-soak.jsonl)
+  --interval-sec <n>   sample period (default 30)
+  --duration-sec <n>   run length (default 0 = until SIGINT/SIGTERM)
+  --container <name>   docker container to stat (default constructive-scale-pg)
+  --pg-host/--pg-port/--pg-user/--pg-password/--pg-database   connection overrides
+                       (PG* env otherwise; PG port defaults to 5433, never 5432)
+  --allow-hub          permit a reserved constructive-hub port (danger)
+  --help
+`;
+
+// Parse a docker `MemUsage` value like "1.234GiB" into bytes. Exported for unit
+// tests. Returns null when the input does not match a known unit.
+export function toBytes(s: string): number | null {
+  const mm = /([\d.]+)\s*(B|KiB|MiB|GiB)/.exec(s);
+  if (!mm) return null;
+  const mult: Record<string, number> = { B: 1, KiB: 1024, MiB: 1024 ** 2, GiB: 1024 ** 3 };
+  return Math.round(parseFloat(mm[1]) * mult[mm[2]]);
+}
+
+function dockerMem(name: string): Promise<any> {
+  return new Promise((resolve) => {
+    execFile(
+      'docker',
+      ['stats', '--no-stream', '--format', '{{.MemUsage}}', name],
+      { timeout: 10000 },
+      (err, stdout) => {
+        if (err) return resolve({ err: String(err.message || err).slice(0, 200) });
+        // e.g. "1.234GiB / 4GiB"
+        const m = String(stdout).trim();
+        const [used, limit] = m.split('/').map((s) => toBytes(s));
+        resolve({ raw: m, usedBytes: used, limitBytes: limit });
+      }
+    );
+  });
+}
+
+async function pgSample(pg: PgConfig): Promise<any> {
+  return withFreshClient(pg, async (client) => {
+    // sequential on purpose: pg queues concurrent query() on one client (deprecated)
+    const act = await client.query("SELECT COALESCE(state, 'null') AS state, count(*)::int AS n FROM pg_stat_activity GROUP BY 1");
+    const cls = await client.query('SELECT count(*)::int AS n FROM pg_class');
+    const size = await client.query('SELECT pg_database_size(current_database())::bigint AS b, (SELECT sum(numbackends)::int FROM pg_stat_database) AS backends');
+    const byState: Record<string, number> = {};
+    let total = 0;
+    for (const r of act.rows) {
+      byState[r.state] = r.n;
+      total += r.n;
+    }
+    return {
+      backendsByState: byState,
+      backendsTotal: total,
+      backendsAllDbs: size.rows[0].backends,
+      pgClassRows: cls.rows[0].n,
+      dbSizeBytes: Number(size.rows[0].b)
+    };
+  });
+}
+
+export async function runPgSampler(argv: Argv): Promise<number> {
+  if (argv.help) return usageExit(USAGE, 0);
+
+  const outFile = typeof argv.out === 'string' ? argv.out : 'out/pg-soak.jsonl';
+  const intervalSec = asInt(argv['interval-sec'], 30);
+  const durationSec = asInt(argv['duration-sec'], 0);
+  const container = typeof argv.container === 'string' ? argv.container : 'constructive-scale-pg';
+
+  let pg: PgConfig;
+  try {
+    pg = pgConfigFromArgv(argv);
+  } catch (e: any) {
+    console.error(`[pg-sampler] ${e && e.message ? e.message : e}`);
+    return 1;
+  }
+
+  fs.mkdirSync(path.dirname(outFile), { recursive: true });
+
+  let stopping = false;
+  const onSig = (): void => {
+    stopping = true;
+  };
+  process.on('SIGINT', onSig);
+  process.on('SIGTERM', onSig);
+
+  const startMs = Date.now();
+  console.error(
+    `[pg-sampler] out=${outFile} interval=${intervalSec}s duration=${durationSec || 'until-signal'}s ` +
+      `container=${container} pg=${pg.host}:${pg.port}/${pg.database}`
+  );
+
+  for (;;) {
+    if (stopping) break;
+    if (durationSec && (Date.now() - startMs) / 1000 >= durationSec) break;
+    const line: any = { t: nowIso() };
+    try {
+      line.docker = await dockerMem(container);
+    } catch (e: any) {
+      line.docker = { err: String(e.message || e).slice(0, 200) };
+    }
+    try {
+      Object.assign(line, await pgSample(pg));
+    } catch (e: any) {
+      line.err = String(e.message || e).slice(0, 200);
+    }
+    fs.appendFileSync(outFile, `${JSON.stringify(line)}\n`);
+    // sleep in small slices so signals stay responsive
+    const until = Date.now() + intervalSec * 1000;
+    while (Date.now() < until && !stopping) await sleep(500);
+  }
+  console.error('[pg-sampler] done');
+  return 0;
+}
diff --git a/packages/perf-harness/src/regression/__tests__/baselines.test.ts b/packages/perf-harness/src/regression/__tests__/baselines.test.ts
new file mode 100644
index 0000000000..f9f0a59396
--- /dev/null
+++ b/packages/perf-harness/src/regression/__tests__/baselines.test.ts
@@ -0,0 +1,45 @@
+import { BASELINES, DEFAULT_BASELINE, getBaseline, listBaselines } from '../baselines';
+
+describe('baselines catalog', () => {
+  test('DEFAULT_BASELINE is the 2026-07 catalog entry', () => {
+    expect(DEFAULT_BASELINE).toBe('catalog61k-2026-07');
+    expect(BASELINES[DEFAULT_BASELINE]).toBeDefined();
+    expect(listBaselines().length).toBeGreaterThanOrEqual(1);
+  });
+
+  test('catalog61k-2026-07 has the exact measured constants + thresholds', () => {
+    const b = getBaseline('catalog61k-2026-07');
+    expect(b.catalogPgClassRows).toBe(61238);
+    expect(b.instanceHeapKBPerRow).toBe(21);
+    expect(b.pgIntrospectionSpikeKBPerRow).toBe(37);
+    expect(b.minViableHeapMB).toBe(1536);
+    expect(b.baseReserveMB).toBe(256);
+    expect(b.buildReserveMB).toBe(768);
+    expect(b.zeroMarginal.tenants).toEqual([10, 20, 32]);
+    expect(b.zeroMarginal.heapMaxMB).toEqual([1460.1, 1459.6, 1464.1]);
+    expect(b.healthy).toEqual({ rps: 188, p99Ms: 21, errRate: 0 });
+    expect(b.capacityByHeapMB['2048']).toBe(1);
+    expect(b.capacityByHeapMB['3584']).toBe(2);
+    expect(b.thresholds).toEqual({
+      maxInstanceHeapKBPerRow: 28,
+      maxZeroMarginalDeltaMB: 100,
+      maxHealthyErrRate: 0.005,
+      maxHealthyP99Ms: 150,
+      maxHeapSlopeMBPerHour: 5
+    });
+  });
+
+  test('catalog61k-2026-07 carries the deep-tier thresholds + constants', () => {
+    const b = getBaseline('catalog61k-2026-07');
+    expect(b.deepThresholds).toEqual({
+      multiApiHeapTolerance: 0.2,
+      settingsSplitExpectedInstances: 2,
+      partitionCreepMaxRowsPerTenantMonth: 200
+    });
+    expect(b.deepConstants).toEqual({ apiSurfacesRoutable: 8 });
+  });
+
+  test('getBaseline throws on an unknown name', () => {
+    expect(() => getBaseline('does-not-exist')).toThrow(/unknown baseline/);
+  });
+});
diff --git a/packages/perf-harness/src/regression/__tests__/compare.test.ts b/packages/perf-harness/src/regression/__tests__/compare.test.ts
new file mode 100644
index 0000000000..c576064cd1
--- /dev/null
+++ b/packages/perf-harness/src/regression/__tests__/compare.test.ts
@@ -0,0 +1,105 @@
+import { getBaseline } from '../baselines';
+import { CheckResult, compareToBaseline, MeasuredRegression, verdictFromChecks } from '../compare';
+
+const bl = getBaseline('catalog61k-2026-07');
+const find = (checks: CheckResult[], name: string): CheckResult => checks.find((c) => c.name === name);
+const cmp = (m: MeasuredRegression): CheckResult[] => compareToBaseline(m, bl);
+
+describe('compareToBaseline boundaries', () => {
+  test('instance-heap passes at the threshold and fails just above', () => {
+    expect(find(cmp({ instanceHeapKBPerRow: 28 }), 'instance-heap').pass).toBe(true);
+    expect(find(cmp({ instanceHeapKBPerRow: 28.1 }), 'instance-heap').pass).toBe(false);
+  });
+
+  test('healthy errRate passes at 0.005 and fails at 0.006', () => {
+    expect(find(cmp({ healthy: { errRate: 0.005 } }), 'healthy-single-bp:errRate').pass).toBe(true);
+    expect(find(cmp({ healthy: { errRate: 0.006 } }), 'healthy-single-bp:errRate').pass).toBe(false);
+  });
+
+  test('healthy p99 passes at 150ms and fails at 151ms', () => {
+    expect(find(cmp({ healthy: { p99Ms: 150 } }), 'healthy-single-bp:p99').pass).toBe(true);
+    expect(find(cmp({ healthy: { p99Ms: 151 } }), 'healthy-single-bp:p99').pass).toBe(false);
+  });
+
+  test('zero-marginal passes at 100MB delta and fails at 101MB', () => {
+    expect(find(cmp({ zeroMarginalDeltaMB: 100 }), 'zero-marginal-tenants').pass).toBe(true);
+    expect(find(cmp({ zeroMarginalDeltaMB: 101 }), 'zero-marginal-tenants').pass).toBe(false);
+  });
+
+  test('thrash-not-crash passes when the server survives and fails on crash', () => {
+    expect(find(cmp({ thrashCrashed: false }), 'thrash-not-crash').pass).toBe(true);
+    expect(find(cmp({ thrashCrashed: true }), 'thrash-not-crash').pass).toBe(false);
+  });
+
+  test('heap-slope passes at threshold and fails above', () => {
+    expect(find(cmp({ heapSlopeMBPerHour: 5 }), 'heap-slope').pass).toBe(true);
+    expect(find(cmp({ heapSlopeMBPerHour: 6 }), 'heap-slope').pass).toBe(false);
+  });
+
+  test('only measurements that were taken produce checks', () => {
+    expect(cmp({}).length).toBe(0);
+    const partial = cmp({ healthy: { errRate: 0 } });
+    expect(partial.map((c) => c.name)).toEqual(['healthy-single-bp:errRate']);
+  });
+});
+
+describe('verdictFromChecks', () => {
+  test('all-pass is exit 0', () => {
+    const checks = cmp({ healthy: { errRate: 0, p99Ms: 21 }, zeroMarginalDeltaMB: 4, bleedViolations: 0 });
+    expect(verdictFromChecks(checks)).toMatchObject({ pass: true, bleed: false, exitCode: 0 });
+  });
+
+  test('a non-bleed failure is exit 1', () => {
+    const checks = cmp({ healthy: { errRate: 0.9 }, bleedViolations: 0 });
+    const v = verdictFromChecks(checks);
+    expect(v.pass).toBe(false);
+    expect(v.bleed).toBe(false);
+    expect(v.exitCode).toBe(1);
+    expect(v.failed).toContain('healthy-single-bp:errRate');
+  });
+
+  test('any bleed violation forces exit 2 even if everything else passes', () => {
+    const clean = cmp({ bleedViolations: 0 });
+    expect(find(clean, 'bleed').pass).toBe(true);
+    expect(verdictFromChecks(clean).exitCode).toBe(0);
+
+    const bled = cmp({ healthy: { errRate: 0, p99Ms: 21 }, bleedViolations: 2 });
+    expect(find(bled, 'bleed').pass).toBe(false);
+    const v = verdictFromChecks(bled);
+    expect(v.bleed).toBe(true);
+    expect(v.exitCode).toBe(2);
+  });
+});
+
+// Advisory checks (the deep-tier scenario probes) are reported but must NEVER
+// contribute to the verdict / exit code.
+describe('verdictFromChecks — advisory checks', () => {
+  const adv = (name: string, pass: boolean): CheckResult => ({ name, pass, value: null, threshold: null, note: '', advisory: true });
+  const grade = (name: string, pass: boolean): CheckResult => ({ name, pass, value: null, threshold: null, note: '' });
+
+  test('a failing advisory check does not flip a passing suite', () => {
+    const v = verdictFromChecks([grade('multi-api-residency', true), adv('partition-creep', false), adv('settings-variant-split', false)]);
+    expect(v.pass).toBe(true);
+    expect(v.exitCode).toBe(0);
+    expect(v.failed).toEqual([]);
+  });
+
+  test('an advisory check named bleed cannot force exit 2', () => {
+    const v = verdictFromChecks([grade('healthy-single-bp:errRate', true), adv('bleed', false)]);
+    expect(v.bleed).toBe(false);
+    expect(v.exitCode).toBe(0);
+  });
+
+  test('a failing GRADEABLE check still fails while advisory noise is ignored', () => {
+    const v = verdictFromChecks([grade('multi-api-residency', false), adv('partition-creep', false)]);
+    expect(v.exitCode).toBe(1);
+    expect(v.failed).toEqual(['multi-api-residency']);
+    expect(v.failed).not.toContain('partition-creep');
+  });
+
+  test('a GRADEABLE bleed still forces exit 2 alongside advisory checks', () => {
+    const v = verdictFromChecks([grade('bleed', false), adv('realtime-dedicated-cost', true)]);
+    expect(v.bleed).toBe(true);
+    expect(v.exitCode).toBe(2);
+  });
+});
diff --git a/packages/perf-harness/src/regression/__tests__/scenarios.test.ts b/packages/perf-harness/src/regression/__tests__/scenarios.test.ts
new file mode 100644
index 0000000000..5003ef5310
--- /dev/null
+++ b/packages/perf-harness/src/regression/__tests__/scenarios.test.ts
@@ -0,0 +1,200 @@
+import { Tenant } from '../../core/fleetfile';
+import { verdictFromChecks } from '../compare';
+import {
+  buildResidencyAbortCheck,
+  buildTeardownLeftoverWarning,
+  computeCreepProjection,
+  DEEP_SCENARIOS,
+  deriveSurfaceFleets,
+  parsePartitionIntervalSeconds,
+  rewriteHostPrefix,
+  scenarioEnabled,
+  SECONDS_PER_MONTH
+} from '../scenarios';
+
+// ---------------------------------------------------------------------------
+// fleet host-rewrite derivation
+// ---------------------------------------------------------------------------
+describe('rewriteHostPrefix', () => {
+  test('rewrites the leading api- label to another surface', () => {
+    expect(rewriteHostPrefix('api-factory2-fab4d29f.localhost', 'api', 'admin')).toBe('admin-factory2-fab4d29f.localhost');
+    expect(rewriteHostPrefix('api-factory2-fab4d29f.localhost', 'api', 'usage')).toBe('usage-factory2-fab4d29f.localhost');
+  });
+
+  test('returns null when the from-prefix does not match', () => {
+    expect(rewriteHostPrefix('auth-factory2-fab4d29f.localhost', 'api', 'admin')).toBeNull();
+    expect(rewriteHostPrefix('', 'api', 'admin')).toBeNull();
+    expect(rewriteHostPrefix(undefined as any, 'api', 'admin')).toBeNull();
+  });
+
+  test('only the FIRST label is rewritten (later api- substrings untouched)', () => {
+    expect(rewriteHostPrefix('api-api-x.localhost', 'api', 'admin')).toBe('admin-api-x.localhost');
+  });
+});
+
+describe('deriveSurfaceFleets', () => {
+  const tenants: Tenant[] = [
+    { dbname: 'factory2', apiHost: 'api-factory2-aaaa1111.localhost', authHost: 'auth-factory2-aaaa1111.localhost' },
+    { dbname: 'factory3', apiHost: 'api-factory3-bbbb2222.localhost', authHost: 'auth-factory3-bbbb2222.localhost' }
+  ];
+
+  test('api surface keeps hosts; admin/usage rewrite the label; authHost preserved', () => {
+    const { fleets, warnings } = deriveSurfaceFleets(tenants, ['api', 'admin', 'usage']);
+    expect(warnings).toEqual([]);
+    const api = fleets.find((f) => f.surface === 'api');
+    const admin = fleets.find((f) => f.surface === 'admin');
+    const usage = fleets.find((f) => f.surface === 'usage');
+    expect(api.tenants.map((t) => t.apiHost)).toEqual(['api-factory2-aaaa1111.localhost', 'api-factory3-bbbb2222.localhost']);
+    expect(admin.tenants.map((t) => t.apiHost)).toEqual(['admin-factory2-aaaa1111.localhost', 'admin-factory3-bbbb2222.localhost']);
+    expect(usage.tenants.map((t) => t.apiHost)).toEqual(['usage-factory2-aaaa1111.localhost', 'usage-factory3-bbbb2222.localhost']);
+    // authHost is untouched on every derived surface (login always uses auth).
+    expect(admin.tenants[0].authHost).toBe('auth-factory2-aaaa1111.localhost');
+  });
+
+  test('tenants without apiHost, or with a non-api host, are dropped with a warning', () => {
+    const mixed: Tenant[] = [
+      { dbname: 'ok', apiHost: 'api-ok-1234abcd.localhost' },
+      { dbname: 'nohost' },
+      { dbname: 'weird', apiHost: 'gateway.example.com' }
+    ];
+    const { fleets, warnings } = deriveSurfaceFleets(mixed, ['admin']);
+    expect(fleets[0].tenants.map((t) => t.dbname)).toEqual(['ok']);
+    expect(warnings.some((w) => w.includes('nohost'))).toBe(true);
+    expect(warnings.some((w) => w.includes('weird'))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// creep math
+// ---------------------------------------------------------------------------
+describe('parsePartitionIntervalSeconds', () => {
+  test('common partman intervals', () => {
+    expect(parsePartitionIntervalSeconds('1 day')).toBe(86400);
+    expect(parsePartitionIntervalSeconds('7 days')).toBe(604800);
+    expect(parsePartitionIntervalSeconds('1 week')).toBe(604800);
+    expect(parsePartitionIntervalSeconds('1 hour')).toBe(3600);
+    expect(parsePartitionIntervalSeconds('1 mon')).toBe(SECONDS_PER_MONTH);
+    expect(parsePartitionIntervalSeconds('1 month')).toBe(SECONDS_PER_MONTH);
+  });
+
+  test('clock and mixed forms', () => {
+    expect(parsePartitionIntervalSeconds('01:00:00')).toBe(3600);
+    expect(parsePartitionIntervalSeconds('00:15:00')).toBe(900);
+    expect(parsePartitionIntervalSeconds('1 day 06:00:00')).toBe(86400 + 6 * 3600);
+  });
+
+  test('unparseable / id-based intervals return null', () => {
+    expect(parsePartitionIntervalSeconds('10000')).toBeNull();
+    expect(parsePartitionIntervalSeconds('')).toBeNull();
+    expect(parsePartitionIntervalSeconds(null as any)).toBeNull();
+  });
+});
+
+describe('computeCreepProjection', () => {
+  test('monthly interval → exactly 1 partition/parent/month', () => {
+    const p = computeCreepProjection({
+      rowsPerPartition: 10,
+      partitionedParents: 4,
+      partitionIntervalSeconds: SECONDS_PER_MONTH,
+      instanceHeapKBPerRow: 21
+    });
+    expect(p.intervalsPerMonth).toBe(1);
+    expect(p.partitionsPerMonth).toBe(4);
+    expect(p.rowsPerTenantPerMonth).toBe(40);
+    // 40 rows * 21KB / 1024 = 0.82 MB
+    expect(p.heapCreepMBPerMonthPerTenant).toBeCloseTo(0.82, 2);
+  });
+
+  test('daily interval scales by ~30.44 intervals/month', () => {
+    const p = computeCreepProjection({
+      rowsPerPartition: 5,
+      partitionedParents: 1,
+      partitionIntervalSeconds: 86400,
+      instanceHeapKBPerRow: 21
+    });
+    expect(p.intervalsPerMonth).toBeCloseTo(30.44, 1);
+    expect(p.rowsPerTenantPerMonth).toBeCloseTo(152.19, 1);
+  });
+
+  test('zero / negative inputs never divide-by-zero or go negative', () => {
+    const p = computeCreepProjection({ rowsPerPartition: -5, partitionedParents: -1, partitionIntervalSeconds: 0, instanceHeapKBPerRow: 21 });
+    expect(p.intervalsPerMonth).toBe(0);
+    expect(p.rowsPerTenantPerMonth).toBe(0);
+    expect(p.heapCreepMBPerMonthPerTenant).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// scenario filter
+// ---------------------------------------------------------------------------
+describe('scenarioEnabled', () => {
+  test('all enabled by default', () => {
+    for (const s of DEEP_SCENARIOS) expect(scenarioEnabled(s)).toBe(true);
+  });
+
+  test('--only restricts to the named set', () => {
+    expect(scenarioEnabled('partition-creep', ['partition-creep'])).toBe(true);
+    expect(scenarioEnabled('multi-api-residency', ['partition-creep'])).toBe(false);
+  });
+
+  test('--skip removes, and wins over --only', () => {
+    expect(scenarioEnabled('partition-creep', null, ['partition-creep'])).toBe(false);
+    expect(scenarioEnabled('partition-creep', ['partition-creep'], ['partition-creep'])).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// teardown-leftover warning (settings-variant-split / realtime-dedicated-cost)
+// ---------------------------------------------------------------------------
+describe('buildTeardownLeftoverWarning', () => {
+  test('surfaces a warning naming the scenario and the leftover row count', () => {
+    const w = buildTeardownLeftoverWarning('settings-variant-split', 2);
+    expect(w).not.toBeNull();
+    expect(w).toContain('settings-variant-split');
+    expect(w).toMatch(/left 2 database_settings row/);
+  });
+
+  test('no warning when the teardown restored cleanly (0 rows)', () => {
+    expect(buildTeardownLeftoverWarning('settings-variant-split', 0)).toBeNull();
+  });
+
+  test('no warning when the leftover count is unknown (null — the teardown error already warned)', () => {
+    expect(buildTeardownLeftoverWarning('realtime-dedicated-cost', null)).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// residency fail-closed check (multi-api-residency abort) — the gradeable deep
+// check must not be able to silently PASS when the scenario aborts early
+// ---------------------------------------------------------------------------
+describe('buildResidencyAbortCheck', () => {
+  test('is a FAILING, non-advisory gradeable check that explains the abort', () => {
+    const c = buildResidencyAbortCheck('no baseline metrics sample');
+    expect(c.name).toBe('multi-api-residency');
+    expect(c.pass).toBe(false);
+    expect(c.advisory).toBeUndefined();
+    expect(c.note).toContain('no baseline metrics sample');
+  });
+
+  test('GATES the verdict — an aborted residency scenario cannot silently PASS', () => {
+    const verdict = verdictFromChecks([buildResidencyAbortCheck('boom')]);
+    expect(verdict.pass).toBe(false);
+    expect(verdict.exitCode).toBe(1);
+    expect(verdict.failed).toContain('multi-api-residency');
+  });
+
+  test('advisory-only failures still PASS (the fail-open bug); adding the abort check FAILS (the fix)', () => {
+    const advisoryFailure = {
+      name: 'multi-api-heap-plateau',
+      advisory: true,
+      pass: false,
+      value: 1,
+      threshold: 0,
+      note: 'x'
+    };
+    // Fail-open shape: no gradeable check present → suite still PASSES.
+    expect(verdictFromChecks([advisoryFailure]).pass).toBe(true);
+    // Fail-closed shape: the abort check gates it to FAIL.
+    expect(verdictFromChecks([advisoryFailure, buildResidencyAbortCheck('boom')]).pass).toBe(false);
+  });
+});
diff --git a/packages/perf-harness/src/regression/__tests__/sql.test.ts b/packages/perf-harness/src/regression/__tests__/sql.test.ts
new file mode 100644
index 0000000000..05b689c6e8
--- /dev/null
+++ b/packages/perf-harness/src/regression/__tests__/sql.test.ts
@@ -0,0 +1,136 @@
+import {
+  buildCreateProbePartition,
+  buildDropProbePartition,
+  buildPartConfigLikePatterns,
+  buildSettingsInsert,
+  escapeLikeLiteral,
+  PART_CONFIG_FOR_TENANT_SQL,
+  qid,
+  SCHEMA_UPDATE_CHANNEL,
+  SETTINGS_DELETE_SQL,
+  SETTINGS_FLAGS,
+  splitParentTable
+} from '../sql';
+
+// ---------------------------------------------------------------------------
+// settings-SQL builder — emits exactly the intended INSERT / DELETE
+// ---------------------------------------------------------------------------
+describe('buildSettingsInsert', () => {
+  test('single flag → parameterized one-row INSERT ($1 = database_id, $2 = flag)', () => {
+    expect(buildSettingsInsert(['enable_aggregates'])).toBe(
+      'INSERT INTO services_public.database_settings (database_id, enable_aggregates) VALUES ($1, $2)'
+    );
+  });
+
+  test('multiple flags keep order and placeholder numbering', () => {
+    expect(buildSettingsInsert(['enable_aggregates', 'enable_realtime'])).toBe(
+      'INSERT INTO services_public.database_settings (database_id, enable_aggregates, enable_realtime) VALUES ($1, $2, $3)'
+    );
+  });
+
+  test('rejects an unknown column (allowlist guard) and an empty list', () => {
+    expect(() => buildSettingsInsert(['drop_table' as any])).toThrow(/unknown settings flag/);
+    expect(() => buildSettingsInsert([])).toThrow(/at least one flag/);
+  });
+
+  test('the allowlist is the 12 known feature flags', () => {
+    expect(SETTINGS_FLAGS).toHaveLength(12);
+    expect(SETTINGS_FLAGS).toContain('enable_realtime');
+    expect(SETTINGS_FLAGS).toContain('enable_aggregates');
+  });
+});
+
+describe('settings DELETE + notify channel', () => {
+  test('DELETE targets exactly the seeded database_id set', () => {
+    expect(SETTINGS_DELETE_SQL).toBe(
+      'DELETE FROM services_public.database_settings WHERE database_id = ANY($1::uuid[])'
+    );
+  });
+
+  test('schema:update channel is the server LISTEN channel', () => {
+    expect(SCHEMA_UPDATE_CHANNEL).toBe('schema:update');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// probe-partition DDL builders (reversible pair) + identifier escaping
+// ---------------------------------------------------------------------------
+describe('probe partition DDL', () => {
+  test('CREATE quotes identifiers and inlines validated ISO bounds', () => {
+    const sql = buildCreateProbePartition('factory2-aaaa1111-app-private', 'events', 'events__perfcreep_probe', '2099-01-01 00:00:00+00', '2099-01-08 00:00:00+00');
+    expect(sql).toBe(
+      'CREATE TABLE "factory2-aaaa1111-app-private"."events__perfcreep_probe" ' +
+        'PARTITION OF "factory2-aaaa1111-app-private"."events" ' +
+        "FOR VALUES FROM ('2099-01-01 00:00:00+00') TO ('2099-01-08 00:00:00+00')"
+    );
+  });
+
+  test('DROP is the exact inverse', () => {
+    expect(buildDropProbePartition('s', 'events__perfcreep_probe')).toBe('DROP TABLE IF EXISTS "s"."events__perfcreep_probe"');
+  });
+
+  test('rejects a non-ISO bound (guards the only interpolated literal)', () => {
+    expect(() => buildCreateProbePartition('s', 'p', 'c', "2099'); DROP TABLE x;--", '2099-01-08')).toThrow(/ISO timestamp/);
+  });
+
+  test('qid escapes embedded double-quotes', () => {
+    expect(qid('a"b')).toBe('"a""b"');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parent_table splitting (physical schemas have dashes, never dots)
+// ---------------------------------------------------------------------------
+describe('splitParentTable', () => {
+  test('splits on the last dot', () => {
+    expect(splitParentTable('factory2-aaaa1111-app-private.events')).toEqual({
+      schema: 'factory2-aaaa1111-app-private',
+      table: 'events'
+    });
+  });
+
+  test('returns null when there is no usable dot', () => {
+    expect(splitParentTable('events')).toBeNull();
+    expect(splitParentTable('.events')).toBeNull();
+    expect(splitParentTable('schema.')).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// partman LIKE-pattern building — escape LIKE metacharacters so a schema's
+// underscore/percent cannot over-match a DIFFERENT tenant's parents
+// ---------------------------------------------------------------------------
+describe('escapeLikeLiteral', () => {
+  test('escapes the three LIKE metacharacters (backslash, %, _)', () => {
+    expect(escapeLikeLiteral('foo_bar')).toBe('foo\\_bar');
+    expect(escapeLikeLiteral('a%b')).toBe('a\\%b');
+    expect(escapeLikeLiteral('a\\b')).toBe('a\\\\b');
+  });
+
+  test('leaves dashes and dots untouched (not LIKE metacharacters)', () => {
+    expect(escapeLikeLiteral('factory2-aaaa1111-app-private')).toBe('factory2-aaaa1111-app-private');
+    expect(escapeLikeLiteral('a.b')).toBe('a.b');
+  });
+});
+
+describe('buildPartConfigLikePatterns', () => {
+  test('appends the intended .% table wildcard to each schema', () => {
+    expect(buildPartConfigLikePatterns(['factory2-aaaa1111-app-private'])).toEqual([
+      'factory2-aaaa1111-app-private.%'
+    ]);
+  });
+
+  test('an underscore in a schema is escaped so it cannot match a foreign tenant', () => {
+    // Unescaped, 'foo_bar.%' would ALSO match 'fooXbar.<table>' (a cross-tenant
+    // over-match); escaped, only the literal 'foo_bar.<table>' can match.
+    expect(buildPartConfigLikePatterns(['foo_bar'])).toEqual(['foo\\_bar.%']);
+  });
+
+  test('preserves order and escapes each schema independently', () => {
+    expect(buildPartConfigLikePatterns(['a_b', 'c-d', 'e%f'])).toEqual(['a\\_b.%', 'c-d.%', 'e\\%f.%']);
+  });
+
+  test('the query it feeds still matches with LIKE ANY over $1', () => {
+    expect(PART_CONFIG_FOR_TENANT_SQL).toContain('parent_table LIKE ANY($1)');
+  });
+});
diff --git a/packages/perf-harness/src/regression/baselines.ts b/packages/perf-harness/src/regression/baselines.ts
new file mode 100644
index 0000000000..2851eabf7c
--- /dev/null
+++ b/packages/perf-harness/src/regression/baselines.ts
@@ -0,0 +1,94 @@
+/**
+ * Known-good performance baselines.
+ *
+ * Each baseline captures the measured constants + pass/fail thresholds for one
+ * catalog size, so `regression run` can assert a fresh measurement has not
+ * regressed against it. The seed entry `catalog61k-2026-07` is the 2026-07
+ * blueprint-pooling validation program (see scripts/scale-validate/V2-RESULTS.md
+ * and SIZING.md); the numbers below are transcribed from those documents.
+ */
+
+export interface Baseline {
+  name: string;
+  capturedAt: string;
+  catalogPgClassRows: number;
+  instanceHeapKBPerRow: number;
+  pgIntrospectionSpikeKBPerRow: number;
+  minViableHeapMB: number;
+  baseReserveMB: number;
+  buildReserveMB: number;
+  zeroMarginal: { tenants: number[]; heapMaxMB: number[] };
+  healthy: { rps: number; p99Ms: number; errRate: number };
+  capacityByHeapMB: Record<string, number>;
+  thresholds: {
+    maxInstanceHeapKBPerRow: number;
+    maxZeroMarginalDeltaMB: number;
+    maxHealthyErrRate: number;
+    maxHealthyP99Ms: number;
+    maxHeapSlopeMBPerHour: number;
+  };
+  // Thresholds + constants used ONLY by the `deep`-tier scenario checks
+  // (src/regression/scenarios.ts). Kept separate from `thresholds` so the
+  // quick/standard comparator surface is unchanged.
+  deepThresholds: {
+    // multi-api-residency: allowed |measured - (base + R*I)| / (base + R*I).
+    multiApiHeapTolerance: number;
+    // settings-variant-split: distinct pooled instances expected for one
+    // relation shape when a settings flag differs (control g=[] vs variant g=[…]).
+    settingsSplitExpectedInstances: number;
+    // partition-creep advisory ceiling: projected new catalog rows / tenant / month.
+    partitionCreepMaxRowsPerTenantMonth: number;
+  };
+  deepConstants: {
+    // Number of routable API surfaces per tenant (admin/agent/api/auth/compute/
+    // config/objects/usage — notifications is unrouted). Informational.
+    apiSurfacesRoutable: number;
+  };
+}
+
+export const catalog61k_2026_07: Baseline = {
+  name: 'catalog61k-2026-07',
+  capturedAt: '2026-07-03',
+  catalogPgClassRows: 61238,
+  instanceHeapKBPerRow: 21,
+  pgIntrospectionSpikeKBPerRow: 37,
+  minViableHeapMB: 1536,
+  baseReserveMB: 256,
+  buildReserveMB: 768,
+  zeroMarginal: { tenants: [10, 20, 32], heapMaxMB: [1460.1, 1459.6, 1464.1] },
+  healthy: { rps: 188, p99Ms: 21, errRate: 0 },
+  capacityByHeapMB: { '2048': 1, '3584': 2 },
+  thresholds: {
+    maxInstanceHeapKBPerRow: 28,
+    maxZeroMarginalDeltaMB: 100,
+    maxHealthyErrRate: 0.005,
+    maxHealthyP99Ms: 150,
+    maxHeapSlopeMBPerHour: 5
+  },
+  deepThresholds: {
+    multiApiHeapTolerance: 0.2,
+    settingsSplitExpectedInstances: 2,
+    partitionCreepMaxRowsPerTenantMonth: 200
+  },
+  deepConstants: {
+    apiSurfacesRoutable: 8
+  }
+};
+
+export const BASELINES: Record<string, Baseline> = {
+  [catalog61k_2026_07.name]: catalog61k_2026_07
+};
+
+export const DEFAULT_BASELINE = catalog61k_2026_07.name;
+
+export function getBaseline(name: string): Baseline {
+  const bl = BASELINES[name];
+  if (!bl) {
+    throw new Error(`unknown baseline '${name}'. known: ${Object.keys(BASELINES).join(', ')}`);
+  }
+  return bl;
+}
+
+export function listBaselines(): Baseline[] {
+  return Object.values(BASELINES);
+}
diff --git a/packages/perf-harness/src/regression/compare.ts b/packages/perf-harness/src/regression/compare.ts
new file mode 100644
index 0000000000..eac786eb10
--- /dev/null
+++ b/packages/perf-harness/src/regression/compare.ts
@@ -0,0 +1,143 @@
+/**
+ * Pure regression comparator.
+ *
+ * `compareToBaseline` maps a set of fresh measurements against a `Baseline`'s
+ * thresholds and returns one `CheckResult` per assertion it can evaluate (a
+ * measurement that was not taken produces no check). `verdictFromChecks`
+ * collapses the checks into the suite's tri-state exit code: a failed `bleed`
+ * check is exit 2 (cross-tenant data bleed — the one violation that is never
+ * "just slow"), any other failure is exit 1, all-pass is exit 0.
+ *
+ * ADVISORY checks (the `deep`-tier scenario probes in ./scenarios.ts set
+ * `advisory: true`) are reported like any other check but are IGNORED by
+ * `verdictFromChecks` — an advisory failure never flips `pass`, `bleed`, or the
+ * exit code. They exist to surface findings (per-instance heap cost, partition
+ * creep projection, realtime dedicated-instance behaviour) without turning an
+ * informational regression into a gate failure.
+ *
+ * No IO, no process — this is the unit-tested heart of `regression run`.
+ */
+import { Baseline } from './baselines';
+
+export interface CheckResult {
+  name: string;
+  pass: boolean;
+  value: number | boolean | null;
+  threshold: number | boolean | null;
+  note: string;
+  // When true this check is informational: it is printed + recorded but never
+  // contributes to the suite verdict / exit code (see verdictFromChecks).
+  advisory?: boolean;
+}
+
+export interface MeasuredRegression {
+  instanceHeapKBPerRow?: number;
+  healthy?: { errRate?: number; p99Ms?: number };
+  zeroMarginalDeltaMB?: number;
+  thrashCrashed?: boolean;
+  bleedViolations?: number;
+  heapSlopeMBPerHour?: number;
+}
+
+const has = (v: any): boolean => v !== undefined && v !== null;
+
+export function compareToBaseline(measured: MeasuredRegression, baseline: Baseline): CheckResult[] {
+  const t = baseline.thresholds;
+  const checks: CheckResult[] = [];
+
+  if (has(measured.instanceHeapKBPerRow)) {
+    const value = measured.instanceHeapKBPerRow;
+    checks.push({
+      name: 'instance-heap',
+      value,
+      threshold: t.maxInstanceHeapKBPerRow,
+      pass: value <= t.maxInstanceHeapKBPerRow,
+      note: `KB retained heap per pg_class row (baseline ${baseline.instanceHeapKBPerRow})`
+    });
+  }
+
+  if (measured.healthy && has(measured.healthy.errRate)) {
+    const value = measured.healthy.errRate;
+    checks.push({
+      name: 'healthy-single-bp:errRate',
+      value,
+      threshold: t.maxHealthyErrRate,
+      pass: value <= t.maxHealthyErrRate,
+      note: 'error rate on a single-blueprint subset at capacity'
+    });
+  }
+  if (measured.healthy && has(measured.healthy.p99Ms)) {
+    const value = measured.healthy.p99Ms;
+    checks.push({
+      name: 'healthy-single-bp:p99',
+      value,
+      threshold: t.maxHealthyP99Ms,
+      pass: value <= t.maxHealthyP99Ms,
+      note: 'p99 latency (ms) on a single-blueprint subset at capacity'
+    });
+  }
+
+  if (has(measured.zeroMarginalDeltaMB)) {
+    const value = measured.zeroMarginalDeltaMB;
+    checks.push({
+      name: 'zero-marginal-tenants',
+      value,
+      threshold: t.maxZeroMarginalDeltaMB,
+      pass: value <= t.maxZeroMarginalDeltaMB,
+      note: 'heapMax delta (MB) between low and high tenant-count steps (same blueprint)'
+    });
+  }
+
+  if (has(measured.thrashCrashed)) {
+    checks.push({
+      name: 'thrash-not-crash',
+      value: measured.thrashCrashed,
+      threshold: false,
+      pass: measured.thrashCrashed === false,
+      note: 'server must SURVIVE over-capacity diversity; degraded latency/errors are expected, not failures'
+    });
+  }
+
+  if (has(measured.heapSlopeMBPerHour)) {
+    const value = measured.heapSlopeMBPerHour;
+    checks.push({
+      name: 'heap-slope',
+      value,
+      threshold: t.maxHeapSlopeMBPerHour,
+      pass: value <= t.maxHeapSlopeMBPerHour,
+      note: 'last-half heap growth (MB/hour) — the soak leak signal'
+    });
+  }
+
+  // Bleed is evaluated last and is the exit-2 trigger. Always emit it when a
+  // measurement exists (0 violations is the healthy, common case).
+  if (has(measured.bleedViolations)) {
+    const value = measured.bleedViolations;
+    checks.push({
+      name: 'bleed',
+      value,
+      threshold: 0,
+      pass: value === 0,
+      note: 'cross-tenant sentinel violations across all steps (must be zero)'
+    });
+  }
+
+  return checks;
+}
+
+export interface Verdict {
+  pass: boolean;
+  bleed: boolean;
+  exitCode: 0 | 1 | 2;
+  failed: string[];
+}
+
+export function verdictFromChecks(checks: CheckResult[]): Verdict {
+  // Advisory checks are informational only — they never gate the verdict.
+  const graded = checks.filter((c) => !c.advisory);
+  const failed = graded.filter((c) => !c.pass).map((c) => c.name);
+  const bleed = graded.some((c) => c.name === 'bleed' && !c.pass);
+  const pass = failed.length === 0;
+  const exitCode: 0 | 1 | 2 = bleed ? 2 : pass ? 0 : 1;
+  return { pass, bleed, exitCode, failed };
+}
diff --git a/packages/perf-harness/src/regression/scenarios.ts b/packages/perf-harness/src/regression/scenarios.ts
new file mode 100644
index 0000000000..1234694796
--- /dev/null
+++ b/packages/perf-harness/src/regression/scenarios.ts
@@ -0,0 +1,1209 @@
+/**
+ * Deep-tier scenario checks — the four multi-surface / settings / realtime /
+ * partition probes that run ONLY under `regression run --suite deep`.
+ *
+ * Each scenario is:
+ *   - individually skippable (`--only` / `--skip`, via scenarioEnabled)
+ *   - self-contained: it boots its OWN fresh server(s) via run/server.spawnServer
+ *     and drives light traffic itself via core/gql.gqlFetch (per RECON finding 3);
+ *     no ramp/harness child is required
+ *   - reversible: every mutating SQL statement is paired with its exact inverse
+ *     in a `finally`, and settings mutations refuse to run (skip) if the target
+ *     rows already exist, so the rig is left EXACTLY as found
+ *   - guardrailed: every PG + server port flows through the existing
+ *     assertPortAllowed guardrail (spawnServer + pgConfigFromArgv already do this;
+ *     the ctx handed in is already validated by the suite)
+ *
+ * Only `multi-api-residency` is a GRADEABLE check (the deterministic pooling
+ * residency invariant). Everything else is ADVISORY: reported, never gating.
+ *
+ * The PURE helpers (rewriteHostPrefix / deriveSurfaceFleets / computeCreepProjection
+ * / parsePartitionIntervalSeconds / scenarioEnabled / buildTeardownLeftoverWarning
+ * / buildResidencyAbortCheck) are exported for unit tests and touch no PG or network.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { assertPortAllowed, PgConfig } from '../core/config';
+import { buildSubset, Tenant } from '../core/fleetfile';
+import { gqlFetch, GqlResponse } from '../core/gql';
+import { withFreshClient } from '../core/pgc';
+import { ensureParentDir, readJsonl } from '../core/proc';
+import { spawnServer, SpawnedServer } from '../run/server';
+import { Baseline } from './baselines';
+import { CheckResult } from './compare';
+import {
+  buildCreateProbePartition,
+  buildDropProbePartition,
+  buildPartConfigLikePatterns,
+  buildSettingsInsert,
+  DATABASE_ID_BY_NAME_SQL,
+  IS_PARTITIONED_PARENT_SQL,
+  PART_CONFIG_FOR_TENANT_SQL,
+  PG_CLASS_COUNT_SQL,
+  SCHEMA_UPDATE_CHANNEL,
+  SCHEMA_UPDATE_NOTIFY_SQL,
+  SETTINGS_DELETE_SQL,
+  SETTINGS_EXISTING_SQL,
+  SettingsFlag,
+  splitParentTable,
+  TENANT_SCHEMAS_SQL
+} from './sql';
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+const round1 = (n: number): number => Math.round(n * 10) / 10;
+const round2 = (n: number): number => Math.round(n * 100) / 100;
+const round4 = (n: number): number => Math.round(n * 10000) / 10000;
+const MB = (bytes: number): number => round1(bytes / 1024 / 1024);
+
+// ===========================================================================
+// Registry + filter (pure)
+// ===========================================================================
+
+export const DEEP_SCENARIOS = [
+  'multi-api-residency',
+  'settings-variant-split',
+  'realtime-dedicated-cost',
+  'partition-creep'
+] as const;
+
+export type DeepScenarioName = (typeof DEEP_SCENARIOS)[number];
+
+// `--only a,b` restricts to that set; `--skip a,b` removes from the set; skip
+// wins over only. Empty/absent `only` means "all not skipped".
+export function scenarioEnabled(name: string, only?: string[] | null, skip?: string[] | null): boolean {
+  if (skip && skip.includes(name)) return false;
+  if (only && only.length > 0) return only.includes(name);
+  return true;
+}
+
+// ===========================================================================
+// Host-rewrite derivation (pure)
+// ===========================================================================
+
+// Rewrite the leading `<from>-` label of a virtual host to `<to>-`. The rig's
+// tenant hosts are `api-<tenant>-<hex8>.<domain>`; the admin/usage/… surfaces
+// share the tenant+hex+domain and differ only in this first label. Returns null
+// when `host` does not start with `<from>-`.
+export function rewriteHostPrefix(host: string, fromPrefix: string, toPrefix: string): string | null {
+  if (!host || typeof host !== 'string') return null;
+  const from = `${fromPrefix}-`;
+  if (!host.startsWith(from)) return null;
+  return `${toPrefix}-${host.slice(from.length)}`;
+}
+
+export interface SurfaceFleet {
+  surface: string;
+  tenants: Tenant[]; // each tenant's apiHost rewritten to this surface's host
+}
+
+// Derive a per-surface fleet by rewriting each tenant's apiHost. `surfaces`
+// entries other than 'api' rewrite the `api-` label to `<surface>-`; 'api'
+// keeps the host as-is. authHost is preserved unchanged (login always uses the
+// auth surface). Tenants without an apiHost, or whose apiHost cannot be
+// rewritten, are dropped from that surface's fleet (with a warning).
+export function deriveSurfaceFleets(
+  tenants: Tenant[],
+  surfaces: string[]
+): { fleets: SurfaceFleet[]; warnings: string[] } {
+  const warnings: string[] = [];
+  const fleets: SurfaceFleet[] = [];
+  for (const surface of surfaces) {
+    const out: Tenant[] = [];
+    for (const t of tenants) {
+      if (!t.apiHost) {
+        warnings.push(`${t.dbname}: no apiHost; dropped from ${surface} surface`);
+        continue;
+      }
+      const host = surface === 'api' ? t.apiHost : rewriteHostPrefix(t.apiHost, 'api', surface);
+      if (!host) {
+        warnings.push(`${t.dbname}: apiHost '${t.apiHost}' has no 'api-' label; dropped from ${surface} surface`);
+        continue;
+      }
+      out.push({ ...t, apiHost: host });
+    }
+    fleets.push({ surface, tenants: out });
+  }
+  return { fleets, warnings };
+}
+
+// ===========================================================================
+// Partition-creep math (pure)
+// ===========================================================================
+
+// Average calendar month (30.4375 d) — matches the 'month' unit weight in
+// parsePartitionIntervalSeconds so a monthly interval yields exactly 1/month.
+export const SECONDS_PER_MONTH = 30.4375 * 24 * 3600;
+
+const INTERVAL_UNIT_SECONDS: Record<string, number> = {
+  sec: 1, secs: 1, second: 1, seconds: 1,
+  min: 60, mins: 60, minute: 60, minutes: 60,
+  hour: 3600, hours: 3600, hr: 3600, hrs: 3600,
+  day: 86400, days: 86400,
+  week: 604800, weeks: 604800,
+  mon: SECONDS_PER_MONTH, mons: SECONDS_PER_MONTH, month: SECONDS_PER_MONTH, months: SECONDS_PER_MONTH,
+  year: 365.25 * 24 * 3600, years: 365.25 * 24 * 3600
+};
+
+// Parse a Postgres/partman interval string ('1 day', '7 days', '1 mon',
+// '01:00:00', '1 day 06:00:00') into seconds. Returns null when nothing
+// recognizable is found (e.g. an id-based partition interval like '10000').
+export function parsePartitionIntervalSeconds(interval: string): number | null {
+  if (!interval || typeof interval !== 'string') return null;
+  const s = interval.trim().toLowerCase();
+  if (!s) return null;
+
+  // Pure clock form HH:MM:SS.
+  const pureClock = /^(\d+):(\d{2}):(\d{2})$/.exec(s);
+  if (pureClock) return Number(pureClock[1]) * 3600 + Number(pureClock[2]) * 60 + Number(pureClock[3]);
+
+  let total = 0;
+  let matched = false;
+  const re = /(\d+(?:\.\d+)?)\s*([a-z]+)/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(s)) !== null) {
+    const weight = INTERVAL_UNIT_SECONDS[m[2]];
+    if (weight === undefined) continue;
+    total += Number(m[1]) * weight;
+    matched = true;
+  }
+  // Trailing clock component in a mixed interval, e.g. '1 day 06:00:00'.
+  const trailingClock = /(?:^|\s)(\d+):(\d{2}):(\d{2})(?:\s|$)/.exec(s);
+  if (trailingClock && matched) {
+    total += Number(trailingClock[1]) * 3600 + Number(trailingClock[2]) * 60 + Number(trailingClock[3]);
+  }
+  return matched ? total : null;
+}
+
+export interface CreepInputs {
+  rowsPerPartition: number;
+  partitionedParents: number;
+  partitionIntervalSeconds: number;
+  instanceHeapKBPerRow: number;
+}
+
+export interface CreepProjection {
+  intervalsPerMonth: number;
+  partitionsPerMonth: number;
+  rowsPerTenantPerMonth: number;
+  heapCreepMBPerMonthPerTenant: number;
+}
+
+// Project monthly catalog + heap creep for ONE tenant from a measured
+// rows-per-partition, the count of partitioned parents, and the (uniform)
+// partition interval. heap uses the sizing constant KB/pg_class-row.
+export function computeCreepProjection(inp: CreepInputs): CreepProjection {
+  const s = inp.partitionIntervalSeconds;
+  const intervalsPerMonth = s > 0 ? SECONDS_PER_MONTH / s : 0;
+  const parents = Math.max(0, inp.partitionedParents);
+  const rowsPer = Math.max(0, inp.rowsPerPartition);
+  const kbPerRow = Math.max(0, inp.instanceHeapKBPerRow);
+  const partitionsPerMonth = parents * intervalsPerMonth;
+  const rowsPerTenantPerMonth = partitionsPerMonth * rowsPer;
+  const heapCreepMBPerMonthPerTenant = (rowsPerTenantPerMonth * kbPerRow) / 1024;
+  return {
+    intervalsPerMonth: round2(intervalsPerMonth),
+    partitionsPerMonth: round2(partitionsPerMonth),
+    rowsPerTenantPerMonth: round2(rowsPerTenantPerMonth),
+    heapCreepMBPerMonthPerTenant: round2(heapCreepMBPerMonthPerTenant)
+  };
+}
+
+// ===========================================================================
+// Scenario context + result
+// ===========================================================================
+
+export interface ScenarioContext {
+  suite: string;
+  pg: PgConfig;
+  port: number;
+  deepHeapMb: number; // --deep-heap-mb (multi-api residency server)
+  heapMb: number; // regression --heap-mb (the capacity-2 thrash sub-check)
+  outDir: string;
+  repoRoot: string;
+  serverCmd: string[];
+  allowHub: boolean;
+  catalogRows: number;
+  baseline: Baseline;
+  fleet: Tenant[];
+  drifted: any;
+  sameBpRegex?: string;
+  only?: string[] | null;
+  skip?: string[] | null;
+  creds: { email: string; password: string | null };
+}
+
+export interface ScenarioResult {
+  name: string;
+  ran: boolean;
+  skipped?: string;
+  checks: CheckResult[];
+  data?: any;
+  warnings?: string[];
+  error?: string;
+}
+
+const skippedResult = (name: string, reason: string): ScenarioResult => ({
+  name,
+  ran: false,
+  skipped: reason,
+  checks: []
+});
+
+// ===========================================================================
+// Server + metrics helpers (internal)
+// ===========================================================================
+
+interface BootedServer {
+  server: SpawnedServer;
+  metricsFile: string;
+}
+
+async function bootFreshServer(
+  ctx: ScenarioContext,
+  tag: string,
+  heapMb: number,
+  opts?: { metricsEndpoint?: boolean }
+): Promise<BootedServer> {
+  assertPortAllowed(ctx.port, ctx.allowHub, 'server-port');
+  const metricsFile = path.join(ctx.outDir, `deep-metrics-${tag}.jsonl`);
+  if (fs.existsSync(metricsFile)) fs.rmSync(metricsFile);
+  // Size the LRU cache from the MEASURED per-instance heap (catalog pg_class
+  // rows x baseline KB/row), NOT graphile-cache's 512MB default. Without this
+  // the server derives GRAPHILE_CACHE_MAX for ~0.5GB instances (6 @3584MB,
+  // 13 @7168MB) while each real instance retains ~1.3GB here — it would admit
+  // far more instances than the heap can hold, defeat ensureCacheHeadroom's
+  // evict-before-build guard, and risk a genuine OOM/SIGABRT. At the measured
+  // size the cap matches the baseline capacity model (e.g. 2 @3584MB), so the
+  // thrash sub-check's "cap < surfaces" premise and the residency hot-set-fits
+  // premise both actually hold.
+  const instanceHeapBytes = Math.max(1, Math.round(ctx.catalogRows * ctx.baseline.instanceHeapKBPerRow * 1024));
+  const server = await spawnServer({
+    name: `deep-${tag}`,
+    port: ctx.port,
+    heapMb,
+    metricsFile,
+    pg: ctx.pg,
+    repoRoot: ctx.repoRoot,
+    outDir: ctx.outDir,
+    serverCmd: ctx.serverCmd,
+    instanceHeapBytes,
+    metricsEndpoint: opts?.metricsEndpoint === true,
+    detached: false,
+    allowHub: ctx.allowHub
+  });
+  return { server, metricsFile };
+}
+
+async function stopServer(server: SpawnedServer | null): Promise<void> {
+  if (!server) return;
+  try {
+    await server.stop();
+  } catch {
+    /* already gone */
+  }
+  // Let the OS release the listen socket before the next scenario re-binds it.
+  await sleep(2000);
+}
+
+const latestMetrics = (metricsFile: string): any | null => {
+  const rows = readJsonl(metricsFile);
+  return rows.length ? rows[rows.length - 1] : null;
+};
+
+const cacheSizeOf = (s: any): number => (s && s.cache && typeof s.cache.size === 'number' ? s.cache.size : 0);
+const cacheKeysOf = (s: any): number => (s && s.cache && typeof s.cache.keys === 'number' ? s.cache.keys : 0);
+const buildsOf = (s: any): number => (s && s.counters && typeof s.counters.builds === 'number' ? s.counters.builds : 0);
+const heapUsedMBOf = (s: any): number => (s && typeof s.heapUsed === 'number' ? MB(s.heapUsed) : 0);
+const lruEvictionsOf = (s: any): number => (s && s.counters && s.counters.evictions ? s.counters.evictions.lru || 0 : 0);
+const evictionsTotalOf = (s: any): number => {
+  const e = s && s.counters && s.counters.evictions;
+  return e ? (e.lru || 0) + (e.ttl || 0) + (e.manual || 0) + (e.governor || 0) : 0;
+};
+
+// Wait until the metrics sampler has written at least one line (~10s cadence).
+async function waitForBaselineSample(metricsFile: string, timeoutMs = 90000): Promise<any | null> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const s = latestMetrics(metricsFile);
+    if (s) return s;
+    await sleep(2000);
+  }
+  return latestMetrics(metricsFile);
+}
+
+// Wait for a metrics sample strictly NEWER than `afterTs` (the sampler writes a
+// fresh line ~every 10s). Used to snapshot counters AFTER an action completes so
+// a stale line can't misattribute the action's builds/evictions to a later
+// window. Falls back to the latest sample on timeout.
+async function waitForSampleAfter(metricsFile: string, afterTs: string | undefined, timeoutMs = 15000): Promise<any | null> {
+  const deadline = Date.now() + timeoutMs;
+  let last = latestMetrics(metricsFile);
+  while (Date.now() < deadline) {
+    last = latestMetrics(metricsFile);
+    if (last && (!afterTs || last.ts !== afterTs)) return last;
+    await sleep(1000);
+  }
+  return last;
+}
+
+const COLD_TIMEOUT_MS = 300000;
+const WARM_TIMEOUT_MS = 15000;
+
+// A `{ __typename }` probe — builds the tenant's PostGraphile instance on first
+// hit (no auth, universally valid; see RECON finding 4). Retries transient 503
+// SERVICE_ROTATING while the instance builds.
+async function coldProbe(host: string, port: number, retries = 8): Promise<GqlResponse> {
+  let r: GqlResponse = { status: 0, ok: false, elapsedMs: 0, error: 'not-attempted' };
+  for (let i = 0; i <= retries; i++) {
+    r = await gqlFetch({ host, port, query: '{ __typename }', timeoutMs: COLD_TIMEOUT_MS });
+    if (r.status !== 503) return r;
+    await sleep(1500);
+  }
+  return r;
+}
+
+const warmProbe = (host: string, port: number): Promise<GqlResponse> =>
+  gqlFetch({ host, port, query: '{ __typename }', timeoutMs: WARM_TIMEOUT_MS });
+
+const answered = (r: GqlResponse): boolean =>
+  r.status === 200 && !r.error && !(r.json && Array.isArray(r.json.errors) && r.json.errors.length > 0);
+
+// Pick up to N group-0 (single-blueprint) tenants that carry the fields a
+// scenario needs. buildSubset is the same pure selector the standard checks use.
+function pickGroup0(ctx: ScenarioContext, n: number): Tenant[] {
+  try {
+    return buildSubset(ctx.fleet, ctx.drifted || {}, { tenants: n, sameBpRegex: ctx.sameBpRegex }).tenants;
+  } catch {
+    return [];
+  }
+}
+
+// Resolve a tenant's control-plane database id (uuid) — from the manifest when
+// present, else by name from metaschema_public.database.
+async function resolveDatabaseId(client: any, t: Tenant): Promise<string | null> {
+  if (t.databaseId) return String(t.databaseId);
+  const r = await client.query(DATABASE_ID_BY_NAME_SQL, [t.dbname]);
+  return r.rows[0] ? String(r.rows[0].id) : null;
+}
+
+// Resolve db ids for the target tenants and REFUSE to proceed (throw 'SKIP: …')
+// if any already carry a settings row — this phase performs NO mutation, so a
+// skip here leaves the rig exactly as found.
+async function resolveAndPrecheck(ctx: ScenarioContext, tenants: Tenant[]): Promise<string[]> {
+  return withFreshClient(ctx.pg, async (client): Promise<string[]> => {
+    const ids: string[] = [];
+    for (const t of tenants) {
+      const id = await resolveDatabaseId(client, t);
+      if (!id) throw new Error(`could not resolve database id for ${t.dbname}`);
+      ids.push(id);
+    }
+    const existing = await client.query(SETTINGS_EXISTING_SQL, [ids]);
+    if (existing.rows.length > 0) {
+      throw new Error(
+        `SKIP: ${existing.rows.length} target tenant(s) already carry a database_settings row; ` +
+          'refusing to mutate (would break exact-restore teardown)'
+      );
+    }
+    return ids;
+  });
+}
+
+// INSERT one settings row per id (all requested flags set true), pushing each
+// committed id into `inserted` so teardown deletes PRECISELY what landed — even
+// if a later INSERT throws mid-way.
+async function seedSettings(ctx: ScenarioContext, ids: string[], flags: SettingsFlag[], inserted: string[]): Promise<void> {
+  const insertSql = buildSettingsInsert(flags);
+  const values = flags.map(() => true);
+  await withFreshClient(ctx.pg, async (client): Promise<void> => {
+    for (const id of ids) {
+      await client.query(insertSql, [id, ...values]);
+      inserted.push(id);
+    }
+  });
+}
+
+// DELETE exactly the seeded rows + a best-effort schema:update NOTIFY, then
+// report how many survived. Never throws (teardown failures become warnings);
+// an empty id list is a no-op.
+async function teardownSettings(
+  ctx: ScenarioContext,
+  ids: string[]
+): Promise<{ rowsRemaining: number | null; error: string | null }> {
+  if (!ids.length) return { rowsRemaining: 0, error: null };
+  try {
+    return await withFreshClient(ctx.pg, async (client): Promise<{ rowsRemaining: number; error: null }> => {
+      await client.query(SETTINGS_DELETE_SQL, [ids]);
+      for (const id of ids) {
+        await client.query(SCHEMA_UPDATE_NOTIFY_SQL, [SCHEMA_UPDATE_CHANNEL, id]).catch(() => {});
+      }
+      const left = await client.query(SETTINGS_EXISTING_SQL, [ids]);
+      return { rowsRemaining: left.rows.length, error: null };
+    });
+  } catch (e: any) {
+    return { rowsRemaining: null, error: String(e && e.message ? e.message : e) };
+  }
+}
+
+// Surface a non-exact teardown into the suite warnings: when a scenario's
+// teardown left settings rows behind (rowsRemaining > 0) the rig is no longer
+// exactly as found, and that must be VISIBLE in the verdict output — not merely
+// recorded in `data`. Returns the warning string, or null when nothing leaked
+// (0 rows) or the leftover count is unknown (null — the teardown itself already
+// pushed its own error warning). Pure (no PG/IO); exported for unit tests.
+export function buildTeardownLeftoverWarning(scenario: string, rowsRemaining: number | null): string | null {
+  if (typeof rowsRemaining === 'number' && rowsRemaining > 0) {
+    return `${scenario} TEARDOWN left ${rowsRemaining} database_settings row(s) behind (manual cleanup may be needed)`;
+  }
+  return null;
+}
+
+// ===========================================================================
+// 1) multi-api-residency  (GRADEABLE residency + ADVISORY heap / thrash)
+// ===========================================================================
+
+const SURFACES = ['api', 'admin', 'usage'] as const; // + auth via authHost
+
+// Fail-CLOSED CheckResult for the residency invariant when the scenario aborts
+// before it can be measured. NON-advisory (no `advisory` flag) so it GATES the
+// verdict — the whole point is that the suite must not silently PASS when the
+// one gradeable deep check never ran. Pure; exported for unit tests.
+export function buildResidencyAbortCheck(errorMessage: string): CheckResult {
+  return {
+    name: 'multi-api-residency',
+    pass: false,
+    value: null,
+    threshold: 0,
+    note: `residency invariant NOT established — scenario aborted before measurement: ${errorMessage}`
+  };
+}
+
+export async function runMultiApiResidency(ctx: ScenarioContext): Promise<ScenarioResult> {
+  const name = 'multi-api-residency';
+  const warnings: string[] = [];
+
+  const tenants = pickGroup0(ctx, 10).filter((t) => t.apiHost);
+  if (tenants.length === 0) return skippedResult(name, 'no group-0 tenants with an apiHost');
+
+  // Derive api/admin/usage surface fleets by host-rewrite; auth uses authHost.
+  const { fleets, warnings: dw } = deriveSurfaceFleets(tenants, SURFACES as unknown as string[]);
+  warnings.push(...dw);
+  const surfaceTargets: { surface: string; hosts: string[] }[] = [];
+  for (const f of fleets) {
+    const hosts = f.tenants.map((t) => t.apiHost).filter(Boolean) as string[];
+    if (hosts.length) surfaceTargets.push({ surface: f.surface, hosts });
+  }
+  const authHosts = tenants.map((t) => t.authHost).filter(Boolean) as string[];
+  if (authHosts.length) surfaceTargets.push({ surface: 'auth', hosts: authHosts });
+
+  const R = surfaceTargets.length;
+  if (R < 2) return skippedResult(name, `only ${R} routable surface(s) derivable; need >= 2`);
+
+  const data: any = {
+    surfaces: surfaceTargets.map((s) => s.surface),
+    tenantCount: tenants.length,
+    expectedResidency: R
+  };
+
+  // -- primary server at --deep-heap-mb (capacity should be >= R) -----------
+  let booted: BootedServer | null = null;
+  const checks: CheckResult[] = [];
+  try {
+    booted = await bootFreshServer(ctx, 'multiapi', ctx.deepHeapMb);
+    const base = await waitForBaselineSample(booted.metricsFile);
+    if (!base) throw new Error('no baseline metrics sample from the deep-heap server');
+    const baseHeapMB = heapUsedMBOf(base);
+    data.deepHeapMb = ctx.deepHeapMb;
+    data.baseHeapMB = baseHeapMB;
+
+    // Cold-build every surface across every tenant. NOTE: on THIS rig each
+    // (surface, tenant) is its OWN blueprint instance — computeBlueprintKey folds
+    // the per-tenant dbname into the key (middleware/blueprint.ts) and every
+    // tenant here has a distinct dbname, so tenants do NOT collapse to one
+    // instance per surface. This sweep is advisory reachability; the gradeable
+    // invariant below is pool REUSE of the held-hot set, not cross-tenant collapse.
+    const coldOk: Record<string, number> = {};
+    for (const st of surfaceTargets) {
+      coldOk[st.surface] = 0;
+      for (const host of st.hosts) {
+        const r = await coldProbe(host, ctx.port);
+        if (answered(r)) coldOk[st.surface]++;
+      }
+    }
+    data.coldOk = coldOk;
+
+    // Optional faithful "auth via login" — best effort, records nothing gating.
+    if (ctx.creds.password && authHosts.length) {
+      const login = await attemptSignIn(authHosts[0], ctx.port, ctx.creds);
+      data.authLogin = login;
+    }
+
+    // -- prime, then hold ONE host per surface HOT for ~120s -----------------
+    // Gradeable invariant: pool REUSE. Once the R hot instances are resident,
+    // re-serving them must trigger ZERO rebuilds (the pool returns the CACHED
+    // instance, not a fresh build per request) and ZERO LRU evictions (the hot
+    // set fits — which is why the server is sized from the measured per-instance
+    // heap; see bootFreshServer). A pooling regression — unstable keys, or a
+    // collapse that mints a per-request instance — surfaces here as the builds
+    // counter CLIMBING during the hold. cache.size >= R alone can't detect that
+    // (>= R instances already exist from the cold sweep). The cold sweep above
+    // may have LRU-evicted the hot hosts, so PRIME them, then measure the
+    // builds/eviction DELTA across the steady hold.
+    const holdHosts = surfaceTargets.map((st) => ({ surface: st.surface, host: st.hosts[0] }));
+    for (const h of holdHosts) await coldProbe(h.host, ctx.port);
+    // Snapshot counters from a sample taken AFTER the prime builds land, so their
+    // builds are not counted against the steady hold below.
+    const primed = await waitForSampleAfter(booted.metricsFile, latestMetrics(booted.metricsFile)?.ts);
+    const buildsAtHoldStart = buildsOf(primed);
+    const lruAtStart = lruEvictionsOf(primed);
+    let maxCacheSize = cacheSizeOf(primed);
+    let maxHeapMB = Math.max(baseHeapMB, heapUsedMBOf(primed));
+    const surfacesAnswered = new Set<string>();
+    const holdMs = 120000;
+    const holdDeadline = Date.now() + holdMs;
+    while (Date.now() < holdDeadline) {
+      for (const h of holdHosts) {
+        const r = await warmProbe(h.host, ctx.port);
+        if (answered(r)) surfacesAnswered.add(h.surface);
+      }
+      const s = latestMetrics(booted.metricsFile);
+      if (s) {
+        maxCacheSize = Math.max(maxCacheSize, cacheSizeOf(s));
+        maxHeapMB = Math.max(maxHeapMB, heapUsedMBOf(s));
+      }
+      await sleep(1500);
+    }
+    const lastSample = latestMetrics(booted.metricsFile);
+    const buildsDuringHold = Math.max(0, buildsOf(lastSample) - buildsAtHoldStart);
+    const lruDuringHold = Math.max(0, lruEvictionsOf(lastSample) - lruAtStart);
+    const cacheSizeReached = Math.max(maxCacheSize, cacheSizeOf(lastSample));
+    const buildsTotal = buildsOf(lastSample);
+
+    data.residency = {
+      perTenantKeys: true, // dbname is folded into the bp key on this rig — no cross-tenant collapse
+      cacheSizeReached,
+      cacheKeysLast: cacheKeysOf(lastSample),
+      buildsTotal,
+      buildsDuringHold,
+      lruEvictionsDuringHold: lruDuringHold,
+      surfacesAnswered: [...surfacesAnswered],
+      maxHeapMB
+    };
+
+    // Deterministic given a correctly heap-sized cache: steady-state re-serving
+    // of the R hot surfaces rebuilds nothing and evicts nothing, and every
+    // surface keeps answering.
+    const residencyOk =
+      buildsDuringHold === 0 && lruDuringHold === 0 && surfacesAnswered.size === R && cacheSizeReached >= R;
+    checks.push({
+      name: 'multi-api-residency',
+      pass: residencyOk,
+      value: buildsDuringHold,
+      threshold: 0,
+      note:
+        `${R} surfaces (${surfaceTargets.map((s) => s.surface).join('/')}) held hot ~120s ` +
+        `(per-tenant dbname keys — no cross-tenant collapse on this rig): rebuilds during hold ` +
+        `${buildsDuringHold} (must be 0 — pool reuse), LRU evictions ${lruDuringHold} (must be 0 — hot ` +
+        `set resident), surfaces answering ${surfacesAnswered.size}/${R}, cache.size ${cacheSizeReached}`
+    });
+
+    // -- ADVISORY: heap plateau consistent with base + R*I (±tolerance) ------
+    const perInstanceMB = (ctx.baseline.instanceHeapKBPerRow * ctx.catalogRows) / 1024;
+    const expectedPlateauMB = baseHeapMB + R * perInstanceMB;
+    const deltaRatio = expectedPlateauMB > 0 ? Math.abs(maxHeapMB - expectedPlateauMB) / expectedPlateauMB : 1;
+    const tol = ctx.baseline.deepThresholds.multiApiHeapTolerance;
+    const measuredPerInstanceMB = R > 0 ? (maxHeapMB - baseHeapMB) / R : 0;
+    data.heapPlateau = {
+      perInstanceExpectedMB: round1(perInstanceMB),
+      expectedPlateauMB: round1(expectedPlateauMB),
+      measuredMaxHeapMB: round1(maxHeapMB),
+      measuredPerInstanceMB: round1(measuredPerInstanceMB),
+      deltaRatio: round4(deltaRatio),
+      tolerance: tol
+    };
+    checks.push({
+      name: 'multi-api-heap-plateau',
+      advisory: true,
+      pass: deltaRatio <= tol,
+      value: round1(maxHeapMB),
+      threshold: round1(expectedPlateauMB),
+      note:
+        `heapUsed plateau ${round1(maxHeapMB)}MB vs base+${R}*I=${round1(expectedPlateauMB)}MB ` +
+        `(±${tol}; measured ~${round1(measuredPerInstanceMB)}MB/instance)`
+    });
+  } catch (e: any) {
+    if (!booted && e && e.server) booted = { server: e.server, metricsFile: '' };
+    const msg = String(e && e.message ? e.message : e);
+    warnings.push(`multi-api-residency primary phase error: ${msg}`);
+    data.error = msg;
+    // Fail CLOSED: residency is the one GRADEABLE deep check. If we aborted
+    // before recording it, the suite would otherwise PASS with the invariant
+    // never tested (advisory checks don't gate). Push a FAILING gradeable result
+    // — unless the residency check already landed — so the verdict reflects that
+    // the invariant could not be established.
+    if (!checks.some((c) => c.name === name)) {
+      checks.push(buildResidencyAbortCheck(msg));
+    }
+  } finally {
+    await stopServer(booted ? booted.server : null);
+  }
+
+  // -- ADVISORY sub-check: same 4 surfaces at heap 3584 (capacity ~2) must ---
+  // -- churn (LRU evictions) WITHOUT the process dying. ----------------------
+  try {
+    const thrash = await runMultiApiThrash(ctx, surfaceTargets);
+    data.thrash = thrash.data;
+    checks.push(thrash.check);
+    warnings.push(...thrash.warnings);
+  } catch (e: any) {
+    warnings.push(`multi-api thrash sub-check error: ${e && e.message ? e.message : e}`);
+  }
+
+  return { name, ran: true, checks, data, warnings };
+}
+
+async function runMultiApiThrash(
+  ctx: ScenarioContext,
+  surfaceTargets: { surface: string; hosts: string[] }[]
+): Promise<{ check: CheckResult; data: any; warnings: string[] }> {
+  const warnings: string[] = [];
+  let booted: BootedServer | null = null;
+  let crashed = false;
+  let evictions = 0;
+  let evictionsStart = 0;
+  try {
+    booted = await bootFreshServer(ctx, 'multiapi-thrash', ctx.heapMb);
+    await waitForBaselineSample(booted.metricsFile);
+    evictionsStart = evictionsTotalOf(latestMetrics(booted.metricsFile));
+    // A few rounds cycling all surfaces forces the sub-capacity cache to evict.
+    for (let round = 0; round < 3; round++) {
+      for (const st of surfaceTargets) {
+        const r = await coldProbe(st.hosts[0], ctx.port, 4);
+        if (r.status === 0 && r.error) warnings.push(`thrash: ${st.surface} network error ${r.error}`);
+      }
+      if (booted.server.exited()) {
+        crashed = true;
+        break;
+      }
+    }
+    await sleep(3000);
+    const last = latestMetrics(booted.metricsFile);
+    evictions = Math.max(0, evictionsTotalOf(last) - evictionsStart);
+    crashed = crashed || booted.server.exited();
+  } catch (e: any) {
+    if (!booted && e && e.server) booted = { server: e.server, metricsFile: '' };
+    crashed = booted ? booted.server.exited() : true;
+    warnings.push(`thrash boot/drive error: ${e && e.message ? e.message : e}`);
+  } finally {
+    await stopServer(booted ? booted.server : null);
+  }
+  const data = { heapMb: ctx.heapMb, evictionsObserved: evictions, serverCrashed: crashed };
+  return {
+    check: {
+      name: 'multi-api-thrash-3584',
+      advisory: true,
+      pass: !crashed && evictions > 0,
+      value: evictions,
+      threshold: 0,
+      note:
+        `at heap ${ctx.heapMb}MB the heap-sized cache cap (~2 for the measured ~1.3GB instances) is below ` +
+        `the ${surfaceTargets.length} cycled surfaces; expect eviction churn without death: ` +
+        `evictions=${evictions}, crashed=${crashed}`
+    },
+    data,
+    warnings
+  };
+}
+
+// Best-effort signIn against an auth host (records outcome, never gates).
+async function attemptSignIn(
+  authHost: string,
+  port: number,
+  creds: { email: string; password: string | null }
+): Promise<any> {
+  if (!creds.password) return { attempted: false, reason: 'no password' };
+  const query =
+    'mutation SignIn($email: String!, $password: String!) ' +
+    '{ signIn(input: { email: $email, password: $password }) { result { accessToken } } }';
+  const r = await gqlFetch({
+    host: authHost,
+    port,
+    query,
+    variables: { email: creds.email, password: creds.password },
+    timeoutMs: WARM_TIMEOUT_MS
+  });
+  return { attempted: true, status: r.status, ok: answered(r) };
+}
+
+// Read the server's LIVE graphileCache key list from the loopback-only
+// /debug/memory endpoint (enabled with metricsEndpoint:true). getCacheStats()
+// keys the cache by the pool DECISION key, so a pooled tenant appears as its
+// `bp:` blueprint key — letting us observe the key itself, not just a count.
+// Returns null when the endpoint is unavailable/unreachable.
+async function fetchGraphileCacheKeys(port: number): Promise<string[] | null> {
+  for (const host of ['127.0.0.1', '[::1]']) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 3000);
+    try {
+      const res = await fetch(`http://${host}:${port}/debug/memory`, { signal: ac.signal });
+      if (!res.ok) continue;
+      const j: any = await res.json();
+      const keys = j && j.graphileCache && Array.isArray(j.graphileCache.keys) ? j.graphileCache.keys : null;
+      if (keys) return keys.filter((k: any) => typeof k === 'string');
+    } catch {
+      /* try the next loopback family */
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  return null;
+}
+
+const bpKeys = (keys: string[] | null): string[] => (keys || []).filter((k) => k.startsWith('bp:'));
+
+// Boot a fresh (metrics-endpoint) server, cold-build ONE tenant's api surface,
+// and return the NEW `bp:` cache key it produced. The before/after key-set diff
+// isolates THIS tenant's key from anything the server built at startup. The
+// server is always stopped before returning.
+async function bootAndCaptureTenantKey(
+  ctx: ScenarioContext,
+  tag: string,
+  tenant: Tenant
+): Promise<{ key: string | null; warning?: string }> {
+  let booted: BootedServer | null = null;
+  try {
+    booted = await bootFreshServer(ctx, tag, ctx.heapMb, { metricsEndpoint: true });
+    await waitForBaselineSample(booted.metricsFile);
+    const before = bpKeys(await fetchGraphileCacheKeys(ctx.port));
+    const r = await coldProbe(tenant.apiHost, ctx.port);
+    if (!answered(r)) return { key: null, warning: `${tag}: tenant ${tenant.dbname} did not answer (status ${r.status})` };
+    await sleep(2000);
+    const after = bpKeys(await fetchGraphileCacheKeys(ctx.port));
+    const added = after.filter((k) => !before.includes(k));
+    if (added.length === 1) return { key: added[0] };
+    if (added.length === 0) {
+      return {
+        key: null,
+        warning: `${tag}: no new bp: key after building ${tenant.dbname} (before=${before.length} after=${after.length}; endpoint or pooling unavailable?)`
+      };
+    }
+    return { key: added.sort()[0], warning: `${tag}: ${added.length} new bp: keys building one tenant; took the first` };
+  } catch (e: any) {
+    // A boot that started the child but timed out on the port attaches it here;
+    // salvage the handle so the finally can stop it instead of leaking it.
+    if (!booted && e && e.server) booted = { server: e.server, metricsFile: '' };
+    throw e;
+  } finally {
+    await stopServer(booted ? booted.server : null);
+  }
+}
+
+// ===========================================================================
+// 2) settings-variant-split  (ADVISORY)
+// ===========================================================================
+
+export async function runSettingsVariantSplit(ctx: ScenarioContext): Promise<ScenarioResult> {
+  const name = 'settings-variant-split';
+  const warnings: string[] = [];
+  const flags: SettingsFlag[] = ['enable_aggregates'];
+
+  // Compare ONE tenant's blueprint key across two fresh-server boots — a CONTROL
+  // boot with no settings row (g=[]) and a VARIANT boot with the flag seeded
+  // (g=[…]). The physical dbname is folded into the key on this per-database rig,
+  // so counting instances across DIFFERENT tenants proves nothing (each tenant
+  // already has its own dbname → its own bp: key regardless of settings). Holding
+  // the SAME tenant constant makes the settings flag the ONLY thing that can move
+  // the key — which is exactly the contract this probe is meant to verify.
+  const pool = pickGroup0(ctx, 6).filter((t) => t.apiHost);
+  if (pool.length < 1) return skippedResult(name, `need >= 1 group-0 tenant with apiHost, have ${pool.length}`);
+  const tenant = pool[0];
+
+  const data: any = {
+    tenant: tenant.dbname,
+    flags,
+    expectedInstances: ctx.baseline.deepThresholds.settingsSplitExpectedInstances,
+    method: 'same-tenant two-boot blueprint-key comparison (dbname held constant to isolate the flag)',
+    note:
+      'Each boot is a NEW process with a FRESH databaseSettingsLoader, so boot 1 ' +
+      'loads g=[] and boot 2 loads g=[…] deterministically — no dependence on the ' +
+      '5-min loader TTL or a schema:update flush (RECON finding b).'
+  };
+
+  // Resolve the db id + refuse to mutate a tenant that already has a settings row
+  // (NO mutation in this phase — a skip here leaves the rig untouched).
+  let tenantIds: string[] = [];
+  try {
+    tenantIds = await resolveAndPrecheck(ctx, [tenant]);
+  } catch (e: any) {
+    const msg = e && e.message ? e.message : String(e);
+    if (msg.startsWith('SKIP:')) return skippedResult(name, msg.slice(5).trim());
+    return { name, ran: false, checks: [], error: msg, warnings };
+  }
+
+  // `insertedIds` tracks exactly what we commit, so teardown deletes precisely
+  // that row even if the variant boot throws mid-way.
+  const insertedIds: string[] = [];
+  const checks: CheckResult[] = [];
+  try {
+    // -- boot 1: CONTROL (no settings row) → capture the tenant's bp: key -----
+    const control = await bootAndCaptureTenantKey(ctx, 'settings-control', tenant);
+    if (control.warning) warnings.push(control.warning);
+    data.controlKey = control.key;
+
+    // -- seed the flag, then boot 2: VARIANT → capture the bp: key again ------
+    await seedSettings(ctx, tenantIds, flags, insertedIds);
+    data.seededDatabaseIds = insertedIds;
+    const variant = await bootAndCaptureTenantKey(ctx, 'settings-variant', tenant);
+    if (variant.warning) warnings.push(variant.warning);
+    data.variantKey = variant.key;
+
+    const bothCaptured = !!control.key && !!variant.key;
+    const distinctKeys = new Set([control.key, variant.key].filter(Boolean)).size;
+    const flagChangedKey = bothCaptured && control.key !== variant.key;
+    const expected = ctx.baseline.deepThresholds.settingsSplitExpectedInstances; // 2 distinct keys
+    data.distinctInstances = distinctKeys;
+    data.flagChangedKey = flagChangedKey;
+
+    checks.push({
+      name: 'settings-variant-split',
+      advisory: true,
+      pass: bothCaptured && distinctKeys >= expected,
+      value: distinctKeys,
+      threshold: expected,
+      note: bothCaptured
+        ? `tenant ${tenant.dbname} yielded ${distinctKeys} distinct blueprint key(s) across ` +
+          `control(g=[]) vs variant(g=[${flags.join(',')}]) boots (expected ${expected}); the flag ` +
+          `${flagChangedKey ? 'CHANGED' : 'did NOT change'} the key`
+        : `could not capture both blueprint keys (control=${control.key ? 'ok' : 'missing'}, ` +
+          `variant=${variant.key ? 'ok' : 'missing'}); see warnings`
+    });
+  } catch (e: any) {
+    warnings.push(`settings-variant-split drive error: ${e && e.message ? e.message : e}`);
+    data.error = String(e && e.message ? e.message : e);
+  } finally {
+    // TEARDOWN: delete exactly the row we inserted + best-effort flush NOTIFY.
+    // Restores the rig to zero settings rows (its measured ground truth).
+    const td = await teardownSettings(ctx, insertedIds);
+    data.teardownRowsRemaining = td.rowsRemaining;
+    if (td.error) warnings.push(`settings-variant-split TEARDOWN failed (manual cleanup may be needed): ${td.error}`);
+    const leftover = buildTeardownLeftoverWarning(name, td.rowsRemaining);
+    if (leftover) warnings.push(leftover);
+  }
+
+  return { name, ran: true, checks, data, warnings };
+}
+
+// ===========================================================================
+// 3) realtime-dedicated-cost  (ADVISORY)
+// ===========================================================================
+
+export async function runRealtimeDedicatedCost(ctx: ScenarioContext): Promise<ScenarioResult> {
+  const name = 'realtime-dedicated-cost';
+  const warnings: string[] = [];
+  const flags: SettingsFlag[] = ['enable_realtime'];
+
+  const pool = pickGroup0(ctx, 6).filter((t) => t.apiHost);
+  if (pool.length < 3) return skippedResult(name, `need >= 3 group-0 tenants with apiHost, have ${pool.length}`);
+  const realtime = pool[0];
+  const controls = pool.slice(1, 3);
+
+  const data: any = {
+    realtimeTenant: realtime.dbname,
+    controlTenants: controls.map((t) => t.dbname),
+    flags,
+    note:
+      'RECON finding c: enable_realtime=true force-UNPOOLS the tenant (dedicated ' +
+      'per-tenant instance) and, absent realtime_public infra, adds a background ' +
+      '5s error-poll — it degrades, it does not crash.'
+  };
+
+  // No-mutation resolve + pre-check (skip cleanly if a row already exists).
+  let realtimeIds: string[] = [];
+  try {
+    realtimeIds = await resolveAndPrecheck(ctx, [realtime]);
+  } catch (e: any) {
+    const msg = e && e.message ? e.message : String(e);
+    if (msg.startsWith('SKIP:')) return skippedResult(name, msg.slice(5).trim());
+    return { name, ran: false, checks: [], error: msg, warnings };
+  }
+
+  const insertedIds: string[] = [];
+  const checks: CheckResult[] = [];
+  let booted: BootedServer | null = null;
+  try {
+    await seedSettings(ctx, realtimeIds, flags, insertedIds);
+    data.seededDatabaseIds = insertedIds;
+
+    booted = await bootFreshServer(ctx, 'realtime', ctx.heapMb);
+    const base = await waitForBaselineSample(booted.metricsFile);
+    const baseHeapMB = heapUsedMBOf(base);
+
+    // 1) control A → the shared pooled control instance (baseline).
+    const cA = await coldProbe(controls[0].apiHost, ctx.port);
+    await sleep(4000);
+    const afterControl = latestMetrics(booted.metricsFile);
+    const cacheAfterControl = cacheSizeOf(afterControl);
+    const heapAfterControlMB = heapUsedMBOf(afterControl);
+
+    // 2) realtime tenant → its own (dedicated / unpooled) instance.
+    const rt = await coldProbe(realtime.apiHost, ctx.port);
+    await sleep(6000);
+    const afterRealtime = latestMetrics(booted.metricsFile);
+    const cacheAfterRealtime = cacheSizeOf(afterRealtime);
+    const heapAfterRealtimeMB = heapUsedMBOf(afterRealtime);
+
+    // 3) control B → must NOT add an instance (controls stay pooled together).
+    const cB = await coldProbe(controls[1].apiHost, ctx.port);
+    await sleep(4000);
+    const afterControlB = latestMetrics(booted.metricsFile);
+    const cacheAfterControlB = cacheSizeOf(afterControlB);
+
+    const realtimeServed = answered(rt);
+    const dedicatedInstance = cacheAfterRealtime > cacheAfterControl; // gained its own
+    const controlsStayPooled = cacheAfterControlB <= cacheAfterRealtime; // B added none
+    const realtimeInstanceHeapMB = round1(heapAfterRealtimeMB - heapAfterControlMB);
+
+    const logTail = booted.server.logTail(4000) || '';
+    const realtimePollNoticed = /realtime_public|realtime|touch_listener|drain_changes/i.test(logTail);
+
+    data.measurements = {
+      baseHeapMB,
+      cacheAfterControl,
+      cacheAfterRealtime,
+      cacheAfterControlB,
+      heapAfterControlMB: round1(heapAfterControlMB),
+      heapAfterRealtimeMB: round1(heapAfterRealtimeMB),
+      realtimeInstanceHeapMB,
+      realtimeServed,
+      dedicatedInstance,
+      controlsStayPooled,
+      realtimeLogSignalsSeen: realtimePollNoticed,
+      controlAStatus: cA.status,
+      realtimeStatus: rt.status,
+      controlBStatus: cB.status
+    };
+
+    if (!realtimeServed) {
+      // Capture the exact failure mode — valuable data, not a suite failure.
+      data.failureMode = {
+        status: rt.status,
+        error: rt.error || null,
+        body: (rt.text || (rt.json ? JSON.stringify(rt.json).slice(0, 400) : '')) || '',
+        serverExited: booted.server.exited(),
+        serverExit: booted.server.exitInfo(),
+        logTail: booted.server.logTail(2000)
+      };
+    }
+
+    checks.push({
+      name: 'realtime-dedicated-cost',
+      advisory: true,
+      pass: realtimeServed && dedicatedInstance && controlsStayPooled,
+      value: realtimeInstanceHeapMB,
+      threshold: null,
+      note: realtimeServed
+        ? `realtime tenant served on a dedicated instance (~${realtimeInstanceHeapMB}MB); ` +
+          `controls stayed pooled (${cacheAfterControlB} instance(s))`
+        : `realtime tenant did NOT serve (status ${rt.status}) — failure mode captured`
+    });
+  } catch (e: any) {
+    if (!booted && e && e.server) booted = { server: e.server, metricsFile: '' };
+    warnings.push(`realtime-dedicated-cost drive error: ${e && e.message ? e.message : e}`);
+    data.error = String(e && e.message ? e.message : e);
+    checks.push({
+      name: 'realtime-dedicated-cost',
+      advisory: true,
+      pass: false,
+      value: null,
+      threshold: null,
+      note: `error while measuring realtime tenant: ${data.error}`
+    });
+  } finally {
+    await stopServer(booted ? booted.server : null);
+    const td = await teardownSettings(ctx, insertedIds);
+    data.teardownRowsRemaining = td.rowsRemaining;
+    if (td.error) warnings.push(`realtime-dedicated-cost TEARDOWN failed (manual cleanup may be needed): ${td.error}`);
+    const leftover = buildTeardownLeftoverWarning(name, td.rowsRemaining);
+    if (leftover) warnings.push(leftover);
+  }
+
+  return { name, ran: true, checks, data, warnings };
+}
+
+// ===========================================================================
+// 4) partition-creep  (ADVISORY, pure SQL — no server)
+// ===========================================================================
+
+// Far-future, interval-agnostic window for the throwaway probe partition. No
+// premade partition covers 2099, so the CREATE cannot collide; it is DROPped
+// immediately regardless.
+const PROBE_LO = '2099-01-01 00:00:00+00';
+const PROBE_HI = '2099-01-08 00:00:00+00';
+const PROBE_SUFFIX = '__perfcreep_probe';
+
+export async function runPartitionCreep(ctx: ScenarioContext): Promise<ScenarioResult> {
+  const name = 'partition-creep';
+  const warnings: string[] = [];
+
+  const tenants = pickGroup0(ctx, 3);
+  const tenant = tenants.find((t) => t.databaseId) || tenants[0];
+  if (!tenant) return skippedResult(name, 'no group-0 tenant available');
+
+  const data: any = { tenant: tenant.dbname };
+  const checks: CheckResult[] = [];
+
+  try {
+    await withFreshClient(ctx.pg, async (client): Promise<void> => {
+      const dbId = await resolveDatabaseId(client, tenant);
+      if (!dbId) {
+        warnings.push(`could not resolve database id for ${tenant.dbname}`);
+        return;
+      }
+
+      const schemaRows = await client.query(TENANT_SCHEMAS_SQL, [dbId]);
+      const schemas = schemaRows.rows.map((r: any) => r.schema_name);
+      if (schemas.length === 0) {
+        data.skipped = 'no physical schemas for tenant';
+        return;
+      }
+      const patterns = buildPartConfigLikePatterns(schemas);
+      const partRows = (await client.query(PART_CONFIG_FOR_TENANT_SQL, [patterns])).rows as any[];
+      if (partRows.length === 0) {
+        data.skipped = 'no partman.part_config rows for this tenant (not partitioned / partman absent)';
+        return;
+      }
+
+      // Record every partitioned parent + its interval/premake.
+      const parents = partRows.map((r) => {
+        const intervalSeconds = parsePartitionIntervalSeconds(r.partition_interval);
+        return {
+          parentTable: r.parent_table,
+          partitionInterval: r.partition_interval,
+          intervalSeconds,
+          premake: r.premake
+        };
+      });
+      data.parents = parents;
+      data.partitionedParents = parents.length;
+
+      // Prefer an events parent (RECON: events/billing/limits/user_auth are
+      // partitioned); fall back to the first parent with a parseable interval.
+      const eventsParent =
+        parents.find((p) => /events/i.test(p.parentTable) && p.intervalSeconds) ||
+        parents.find((p) => p.intervalSeconds);
+      if (!eventsParent) {
+        data.skipped = 'no parent with a parseable time interval; cannot measure/project';
+        return;
+      }
+      data.measuredParent = eventsParent.parentTable;
+      const split = splitParentTable(eventsParent.parentTable);
+      if (!split) {
+        data.skipped = `could not split parent_table '${eventsParent.parentTable}'`;
+        return;
+      }
+
+      const isNative = await client.query(IS_PARTITIONED_PARENT_SQL, [split.schema, split.table]);
+      if (isNative.rows.length === 0) {
+        data.skipped = `parent ${eventsParent.parentTable} is not a native partitioned table (relkind<>'p')`;
+        return;
+      }
+
+      // -- measure: create ONE probe partition, diff pg_class, drop, verify ---
+      const child = `${split.table}${PROBE_SUFFIX}`;
+      // Clear any probe child left by a crashed prior run so the baseline is clean.
+      await client.query(buildDropProbePartition(split.schema, child)).catch(() => {});
+      const before = (await client.query(PG_CLASS_COUNT_SQL)).rows[0].n as number;
+      let rowsPerPartition = 0;
+      let restored = before;
+      let created = false;
+      try {
+        await client.query(buildCreateProbePartition(split.schema, split.table, child, PROBE_LO, PROBE_HI));
+        created = true;
+        const after = (await client.query(PG_CLASS_COUNT_SQL)).rows[0].n as number;
+        rowsPerPartition = after - before;
+      } catch (e: any) {
+        warnings.push(`probe partition CREATE failed (measurement skipped): ${e && e.message ? e.message : e}`);
+        data.createError = String(e && e.message ? e.message : e);
+      } finally {
+        if (created) {
+          try {
+            await client.query(buildDropProbePartition(split.schema, child));
+          } catch (e: any) {
+            warnings.push(`probe partition DROP failed — MANUAL CLEANUP NEEDED for ${split.schema}.${child}: ${e && e.message ? e.message : e}`);
+          }
+          restored = (await client.query(PG_CLASS_COUNT_SQL)).rows[0].n as number;
+        }
+      }
+      data.pgClass = { before, restored, rowsPerPartition, restoredToZero: restored === before };
+      if (created && restored !== before) {
+        warnings.push(`partition-creep: pg_class did not return to ${before} (now ${restored}) — investigate leftover objects`);
+      }
+
+      // -- project monthly creep (advisory) -----------------------------------
+      const projection = computeCreepProjection({
+        rowsPerPartition,
+        partitionedParents: parents.length,
+        partitionIntervalSeconds: eventsParent.intervalSeconds as number,
+        instanceHeapKBPerRow: ctx.baseline.instanceHeapKBPerRow
+      });
+      data.projection = projection;
+      data.intervalSecondsUsed = eventsParent.intervalSeconds;
+
+      const ceiling = ctx.baseline.deepThresholds.partitionCreepMaxRowsPerTenantMonth;
+      const measured = rowsPerPartition > 0;
+      checks.push({
+        name: 'partition-creep',
+        advisory: true,
+        pass: measured ? projection.rowsPerTenantPerMonth <= ceiling : true,
+        value: projection.rowsPerTenantPerMonth,
+        threshold: ceiling,
+        note: measured
+          ? `${rowsPerPartition} pg_class rows/partition × ${parents.length} parents → ` +
+            `~${projection.rowsPerTenantPerMonth} rows/tenant/month ` +
+            `(~${projection.heapCreepMBPerMonthPerTenant}MB/tenant/month @ ${ctx.baseline.instanceHeapKBPerRow}KB/row)`
+          : 'measurement skipped (see createError); projection uses rowsPerPartition=0'
+      });
+    });
+  } catch (e: any) {
+    warnings.push(`partition-creep error: ${e && e.message ? e.message : e}`);
+    data.error = String(e && e.message ? e.message : e);
+  }
+
+  if (checks.length === 0 && data.skipped) return skippedResult(name, data.skipped);
+  return { name, ran: true, checks, data, warnings };
+}
+
+// ===========================================================================
+// Orchestrator
+// ===========================================================================
+
+const RUNNERS: Record<DeepScenarioName, (ctx: ScenarioContext) => Promise<ScenarioResult>> = {
+  'multi-api-residency': runMultiApiResidency,
+  'settings-variant-split': runSettingsVariantSplit,
+  'realtime-dedicated-cost': runRealtimeDedicatedCost,
+  'partition-creep': runPartitionCreep
+};
+
+// Run each enabled deep scenario in isolation. A thrown scenario is contained
+// (recorded as an errored result) so one failure never aborts the others — and
+// every scenario has already restored the rig in its own finally.
+export async function runDeepScenarios(ctx: ScenarioContext): Promise<ScenarioResult[]> {
+  const results: ScenarioResult[] = [];
+  for (const scenarioName of DEEP_SCENARIOS) {
+    if (!scenarioEnabled(scenarioName, ctx.only, ctx.skip)) {
+      results.push(skippedResult(scenarioName, 'disabled via --only/--skip'));
+      continue;
+    }
+    try {
+      results.push(await RUNNERS[scenarioName](ctx));
+    } catch (e: any) {
+      results.push({
+        name: scenarioName,
+        ran: false,
+        checks: [],
+        error: `unhandled: ${e && e.message ? e.message : e}`
+      });
+    }
+  }
+  return results;
+}
diff --git a/packages/perf-harness/src/regression/sql.ts b/packages/perf-harness/src/regression/sql.ts
new file mode 100644
index 0000000000..efa5730763
--- /dev/null
+++ b/packages/perf-harness/src/regression/sql.ts
@@ -0,0 +1,191 @@
+/**
+ * SQL builders + constants for the `deep`-tier scenario checks
+ * (src/regression/scenarios.ts).
+ *
+ * Every mutating statement here is PARAMETERIZED and paired with an exact
+ * inverse so a scenario can restore the rig to precisely the state it found:
+ *   - settings INSERT  <-> settings DELETE (by the same database_id set)
+ *   - probe partition CREATE <-> DROP (by the same child name)
+ *
+ * Identifiers that reach a DDL string (schema / table / child names come from
+ * the catalog, never from user argv) are double-quote escaped via `qid`; all
+ * values flow as bind parameters. The flag-column allowlist (`SETTINGS_FLAGS`)
+ * guards the ONE place a column name is interpolated (the settings INSERT).
+ *
+ * No IO here — these are pure string/param builders, unit-tested without PG.
+ */
+
+// LISTEN/NOTIFY channel the server subscribes to for cache invalidation
+// (graphql/server/src/server.ts LISTEN "schema:update"; payload = databaseId).
+export const SCHEMA_UPDATE_CHANNEL = 'schema:update';
+
+// The 12 feature-flag columns on services_public.database_settings (and the
+// matching per-API override columns on services_public.api_settings). Mirrors
+// the loader mapping in packages/express-context/src/loaders/database-settings.ts.
+export const SETTINGS_FLAGS = [
+  'enable_aggregates',
+  'enable_postgis',
+  'enable_search',
+  'enable_direct_uploads',
+  'enable_presigned_uploads',
+  'enable_many_to_many',
+  'enable_connection_filter',
+  'enable_ltree',
+  'enable_llm',
+  'enable_realtime',
+  'enable_bulk',
+  'enable_i18n'
+] as const;
+
+export type SettingsFlag = (typeof SETTINGS_FLAGS)[number];
+
+// Double-quote-escape a SQL identifier (schema / table / child name from the
+// catalog). Mirrors fleet/teardown.ts `qid`.
+export const qid = (s: string): string => `"${String(s).replace(/"/g, '""')}"`;
+
+// ---------------------------------------------------------------------------
+// services_public.database_settings — variant seeding (checks 2 + 3)
+// ---------------------------------------------------------------------------
+
+// Are any of these database_ids ALREADY carrying a settings row? A scenario
+// refuses to mutate (skips) when true, so teardown can never delete a row it
+// did not create — the rig is left exactly as found.
+export const SETTINGS_EXISTING_SQL =
+  'SELECT database_id::text AS database_id FROM services_public.database_settings WHERE database_id = ANY($1::uuid[])';
+
+/**
+ * Parameterized single-row INSERT into services_public.database_settings.
+ * `$1` = database_id; one bind param per requested flag follows, in the order
+ * of `flagColumns`. Columns NOT listed keep their table defaults (postgis/
+ * search/uploads/m2m/connection_filter/ltree ON; aggregates/llm/realtime/bulk/
+ * i18n OFF), matching the rig's implicit per-tenant configuration.
+ *
+ * Throws on an unknown flag column (allowlist guard against injection).
+ */
+export function buildSettingsInsert(flagColumns: SettingsFlag[]): string {
+  if (!flagColumns.length) throw new Error('buildSettingsInsert: at least one flag column required');
+  for (const c of flagColumns) {
+    if (!(SETTINGS_FLAGS as readonly string[]).includes(c)) {
+      throw new Error(`buildSettingsInsert: unknown settings flag column '${c}'`);
+    }
+  }
+  const cols = flagColumns.join(', ');
+  const placeholders = flagColumns.map((_c, i) => `$${i + 2}`).join(', ');
+  return `INSERT INTO services_public.database_settings (database_id, ${cols}) VALUES ($1, ${placeholders})`;
+}
+
+// Exact inverse of the INSERT: remove the rows for precisely the seeded ids.
+export const SETTINGS_DELETE_SQL =
+  'DELETE FROM services_public.database_settings WHERE database_id = ANY($1::uuid[])';
+
+// Notify the server to flush its per-database pooling decisions. NOTE (recon b):
+// this clears the pooling-decision memo + bp: instances but NOT the 5-minute
+// databaseSettingsLoader TTL cache, so a settings change only takes effect
+// deterministically on a FRESH server (which every scenario boots) — the NOTIFY
+// is fired on teardown as a best-effort courtesy to any long-lived listener.
+export const SCHEMA_UPDATE_NOTIFY_SQL = 'SELECT pg_notify($1, $2)';
+
+// ---------------------------------------------------------------------------
+// databaseId + schema resolution
+// ---------------------------------------------------------------------------
+
+// Resolve a tenant's control-plane database id from its name (when the fleet
+// manifest lacks databaseId).
+export const DATABASE_ID_BY_NAME_SQL =
+  'SELECT id::text AS id FROM metaschema_public.database WHERE name = $1';
+
+// Every physical schema of a tenant database (used to scope the partman scan).
+export const TENANT_SCHEMAS_SQL =
+  'SELECT schema_name FROM metaschema_public.schema WHERE database_id = $1 ORDER BY schema_name';
+
+// ---------------------------------------------------------------------------
+// partman.part_config — partition-creep measurement (check 4)
+// ---------------------------------------------------------------------------
+
+// Time-partitioned parents belonging to a tenant's schema set. `$1` is an array
+// of `'<schema>.%'` LIKE patterns built by buildPartConfigLikePatterns, which
+// escapes the LIKE metacharacters in the schema names (so an underscore in a
+// schema cannot act as a single-char wildcard and pull in a DIFFERENT tenant's
+// parents). Matching relies on LIKE's default backslash escape — an explicit
+// ESCAPE clause is not permitted with the `LIKE ANY` quantified form.
+// partition_interval is returned as text and parsed in JS
+// (parsePartitionIntervalSeconds) so a non-time interval simply fails to parse
+// and that parent is skipped, rather than throwing here.
+export const PART_CONFIG_FOR_TENANT_SQL = `
+  SELECT parent_table,
+         partition_interval::text AS partition_interval,
+         premake
+    FROM partman.part_config
+   WHERE parent_table LIKE ANY($1)
+   ORDER BY parent_table`;
+
+// Escape the three LIKE metacharacters (backslash, %, _) in a literal so it
+// matches only itself. PostgreSQL's LIKE treats backslash as its default escape
+// character, so an escaped literal needs no explicit ESCAPE clause.
+export const escapeLikeLiteral = (s: string): string => String(s).replace(/([\\%_])/g, '\\$1');
+
+// Build the `'<schema>.%'` patterns for PART_CONFIG_FOR_TENANT_SQL's `LIKE ANY`.
+// Physical schema names here carry dashes and MAY carry underscores; left
+// unescaped, an underscore is a LIKE single-character wildcard, so a schema
+// 'foo_bar' would yield 'foo_bar.%' and also match a DIFFERENT tenant's
+// 'fooXbar.<table>' parent (a cross-tenant over-match). Escaping the
+// metacharacters pins the schema to itself; the trailing '.%' stays the one
+// intended wildcard (the table component), and the '.' is a literal that anchors
+// the schema/table boundary exactly.
+export function buildPartConfigLikePatterns(schemas: string[]): string[] {
+  return schemas.map((s) => `${escapeLikeLiteral(s)}.%`);
+}
+
+// Confirm a parent is a native partitioned table (relkind 'p') before we add a
+// child to it. `$1` = schema, `$2` = table.
+export const IS_PARTITIONED_PARENT_SQL = `
+  SELECT 1
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+   WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind = 'p'
+   LIMIT 1`;
+
+// pg_class row count — the catalog-size proxy the whole sizing model rides on.
+export const PG_CLASS_COUNT_SQL = 'SELECT count(*)::int AS n FROM pg_class';
+
+/**
+ * CREATE one throwaway future partition of a native partitioned parent. Because
+ * PARTITION OF auto-creates the child's indexes (from the parent's partitioned
+ * indexes) and a toast table, the pg_class delta around this statement is the
+ * TRUE marginal per-partition footprint (table + indexes + toast + toast index).
+ * `lo`/`hi` are far-future ISO timestamps (validated by the caller against
+ * ISO_TS_RE) chosen to never overlap a premade partition, so the CREATE cannot
+ * collide; the child is DROPped in teardown regardless.
+ */
+export function buildCreateProbePartition(
+  schema: string,
+  parent: string,
+  child: string,
+  lo: string,
+  hi: string
+): string {
+  if (!ISO_TS_RE.test(lo) || !ISO_TS_RE.test(hi)) {
+    throw new Error(`buildCreateProbePartition: bound is not an ISO timestamp: ${lo} / ${hi}`);
+  }
+  return (
+    `CREATE TABLE ${qid(schema)}.${qid(child)} PARTITION OF ${qid(schema)}.${qid(parent)} ` +
+    `FOR VALUES FROM ('${lo}') TO ('${hi}')`
+  );
+}
+
+// Exact inverse of the probe CREATE.
+export function buildDropProbePartition(schema: string, child: string): string {
+  return `DROP TABLE IF EXISTS ${qid(schema)}.${qid(child)}`;
+}
+
+// Strict ISO-8601 timestamp (date, or date + time + optional zone). Guards the
+// only literal values interpolated into the probe-partition DDL.
+export const ISO_TS_RE = /^\d{4}-\d{2}-\d{2}([ T]\d{2}:\d{2}:\d{2}(\.\d+)?([+-]\d{2}(:?\d{2})?|Z)?)?$/;
+
+// Split a `schema.table` parent_table into its parts on the LAST dot (physical
+// schema names contain dashes but never dots, so the last dot is the separator).
+export function splitParentTable(parentTable: string): { schema: string; table: string } | null {
+  const i = parentTable.lastIndexOf('.');
+  if (i <= 0 || i >= parentTable.length - 1) return null;
+  return { schema: parentTable.slice(0, i), table: parentTable.slice(i + 1) };
+}
diff --git a/packages/perf-harness/src/regression/suite.ts b/packages/perf-harness/src/regression/suite.ts
new file mode 100644
index 0000000000..5126461bc7
--- /dev/null
+++ b/packages/perf-harness/src/regression/suite.ts
@@ -0,0 +1,410 @@
+/**
+ * regression run — the one-command regression suite.
+ *
+ * Re-runs the load-bearing checks from the 2026-07 validation program against a
+ * fresh build and asserts they have not regressed past the chosen baseline's
+ * thresholds. The heavy lifting (booting servers, driving load) is delegated to
+ * OTHER `perf-harness` subcommands spawned as child processes — this file only
+ * orchestrates:
+ *
+ *   preflight -> (standard) measure instance-heap -> run ramp <generated plan>
+ *             -> aggregate step records -> compare to baseline -> verdict
+ *
+ * Suites:
+ *   quick     healthy-single-bp, zero-marginal-tenants, bleed
+ *   standard  + instance-heap, thrash-not-crash
+ *   deep      + the four scenario probes (multi-api-residency [gradeable],
+ *             settings-variant-split, realtime-dedicated-cost, partition-creep
+ *             [advisory]) — see ./scenarios.ts. Advisory checks report pass/fail
+ *             but never flip the verdict or exit code.
+ *
+ * Exit: 0 pass / 1 fail / 2 bleed (a cross-tenant sentinel violation anywhere).
+ *
+ * NOTE: this path needs a live PG rig + a built server; it is exercised behind
+ * PERF_E2E=1, not by the default `jest` run. The child CLI is invoked as
+ * `node <this-cli-entry> ...`, so it assumes the built dist entry (the gate that
+ * runs regression uses the compiled package).
+ */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+
+import { Argv, asBool, asInt } from '../core/args';
+import { assertPortAllowed, findRepoRoot, pgConfigFromArgv, resolveCreds, resolveOutDir, resolveServerCmd } from '../core/config';
+import { buildSubset, loadFleet, Tenant } from '../core/fleetfile';
+import { withFreshClient } from '../core/pgc';
+import { ensureParentDir, readJsonl } from '../core/proc';
+import { DEFAULT_BASELINE, getBaseline } from './baselines';
+import { compareToBaseline, MeasuredRegression, verdictFromChecks } from './compare';
+import { runDeepScenarios, ScenarioContext, ScenarioResult } from './scenarios';
+
+const USAGE = `perf-harness regression run --fleet <manifest> [--suite quick|standard|deep] \\
+  [--baseline ${DEFAULT_BASELINE}] [--port 3345] [--heap-mb 3584] [--deep-heap-mb 7168] \\
+  [--out-dir ./perf-out] [--drifted <drifted.json>] [--same-bp-regex <re>] \\
+  [--only <scenario,...>] [--skip <scenario,...>] [--server-cmd "node ..."] [--allow-hub]
+
+Re-run the regression suite against a fresh build and compare to a baseline.
+The deep tier adds four scenario probes (--only/--skip filter them by name:
+multi-api-residency, settings-variant-split, realtime-dedicated-cost,
+partition-creep); only multi-api-residency can fail the suite, the rest are
+advisory. Exit 0 pass / 1 fail / 2 bleed.`;
+
+const err = (msg: string): void => console.error(`[regression] ${msg}`);
+
+// True if something is already accepting connections on the port (either
+// loopback family). Used to refuse a run when the target port is occupied.
+function isPortBusy(port: number, timeoutMs = 800): Promise<boolean> {
+  const probe = (host: string): Promise<boolean> =>
+    new Promise((resolve) => {
+      const sock = net.connect({ host, port });
+      let done = false;
+      const finish = (busy: boolean): void => {
+        if (done) return;
+        done = true;
+        sock.destroy();
+        resolve(busy);
+      };
+      sock.setTimeout(timeoutMs);
+      sock.once('connect', () => finish(true));
+      sock.once('timeout', () => finish(false));
+      sock.once('error', () => finish(false));
+    });
+  return Promise.all([probe('127.0.0.1'), probe('::1')]).then((r) => r[0] || r[1]);
+}
+
+interface ChildResult {
+  status: number | null;
+  signal: string | null;
+  stdout: string;
+  stderr: string;
+}
+
+// Invoke THIS CLI (built dist entry) as a child, tee-ing its output to a log
+// file under out-dir. PG credentials go via env (never argv — no `ps` leak).
+function spawnCli(cliEntry: string, cliArgs: string[], env: Record<string, string>, logFile: string): ChildResult {
+  const res = spawnSync(process.execPath, [cliEntry, ...cliArgs], {
+    env: { ...process.env, ...env },
+    encoding: 'utf8',
+    timeout: 45 * 60 * 1000,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  const body = `$ ${cliArgs.join(' ')}\n${res.stdout || ''}${res.stderr || ''}\n`;
+  try {
+    ensureParentDir(logFile);
+    fs.appendFileSync(logFile, body);
+  } catch {
+    /* log best-effort */
+  }
+  return { status: res.status, signal: res.signal, stdout: res.stdout || '', stderr: res.stderr || '' };
+}
+
+function writeFleetFile(dir: string, name: string, subset: any): string {
+  const file = path.join(dir, `regression-fleet-${name}.json`);
+  ensureParentDir(file);
+  fs.writeFileSync(file, JSON.stringify(subset, null, 2) + '\n');
+  return file;
+}
+
+export async function runRegression(argv: Argv): Promise<number> {
+  const fleetFile = typeof argv.fleet === 'string' ? argv.fleet : null;
+  if (!fleetFile) {
+    console.error(USAGE);
+    return 1;
+  }
+  const suite = ['standard', 'deep'].includes(argv.suite) ? argv.suite : 'quick';
+  const baselineName = typeof argv.baseline === 'string' ? argv.baseline : DEFAULT_BASELINE;
+  const port = asInt(argv.port, 3345);
+  const heapMb = asInt(argv['heap-mb'], 3584);
+  const deepHeapMb = asInt(argv['deep-heap-mb'], 7168);
+  const allowHub = asBool(argv['allow-hub']);
+  // Scenario filters (deep tier). Comma lists, same shape as `run ramp --only`.
+  const parseList = (v: any): string[] => (typeof v === 'string' ? v.split(',').map((s) => s.trim()).filter(Boolean) : []);
+  const onlyScenarios = parseList(argv.only);
+  const skipScenarios = parseList(argv.skip);
+
+  let baseline;
+  try {
+    baseline = getBaseline(baselineName);
+  } catch (e: any) {
+    err(e.message);
+    return 1;
+  }
+
+  // --- preflight ------------------------------------------------------------
+  try {
+    assertPortAllowed(port, allowHub, 'server-port');
+  } catch (e: any) {
+    err(e.message);
+    return 1;
+  }
+
+  const repoRoot = findRepoRoot();
+  const outDir = resolveOutDir(argv);
+  const pg = pgConfigFromArgv(argv); // also asserts pg-port hub safety
+  const serverCmd = resolveServerCmd(argv, repoRoot);
+  const cliEntry = process.argv[1];
+  const logFile = path.join(outDir, 'regression.log');
+  const warnings: string[] = [];
+
+  // server dist must exist (unless a custom --server-cmd points elsewhere).
+  const jsEntry = serverCmd.find((a) => a.endsWith('.js'));
+  if (jsEntry && !fs.existsSync(jsEntry)) {
+    err(`server entry not found: ${jsEntry} (build it, or pass --server-cmd). ` + `default is <repo>/packages/cli/dist/index.js`);
+    return 1;
+  }
+
+  // port must be free.
+  if (await isPortBusy(port)) {
+    err(`port ${port} is already in use; pick a free --port or stop the listener`);
+    return 1;
+  }
+
+  // PG reachable + catalog size.
+  let catalogRows: number;
+  try {
+    catalogRows = await withFreshClient(pg, async (c) => {
+      const r = await c.query('SELECT count(*)::int AS n FROM pg_class');
+      return r.rows[0].n as number;
+    });
+  } catch (e: any) {
+    err(`PG not reachable at ${pg.host}:${pg.port}/${pg.database}: ${e.message || e}`);
+    return 1;
+  }
+  err(`preflight ok: catalog=${catalogRows} pg_class rows, port ${port} free, baseline ${baselineName}, suite ${suite}`);
+
+  // --- build subsets + ramp plan -------------------------------------------
+  let fleet: Tenant[];
+  try {
+    fleet = loadFleet(fleetFile).tenants;
+  } catch (e: any) {
+    err(`bad fleet ${fleetFile}: ${e.message || e}`);
+    return 1;
+  }
+  const drifted = typeof argv.drifted === 'string' && fs.existsSync(argv.drifted) ? JSON.parse(fs.readFileSync(argv.drifted, 'utf8')) : {};
+  const sameBpRegex = typeof argv['same-bp-regex'] === 'string' ? argv['same-bp-regex'] : undefined;
+
+  // group-0 size (single known-identical blueprint pool).
+  let maxAvail = 0;
+  try {
+    maxAvail = buildSubset(fleet, drifted, { tenants: 1_000_000, sameBpRegex }).tenants.length;
+  } catch (e: any) {
+    err(`could not derive single-blueprint pool from fleet: ${e.message || e}`);
+    return 1;
+  }
+  if (maxAvail === 0) {
+    err('no single-blueprint tenants matched (check --same-bp-regex); cannot run healthy/zero-marginal checks');
+    return 1;
+  }
+  const lowN = Math.min(10, maxAvail);
+
+  const mix = 'read:0.7,write:0.25,meta:0.05';
+  const steps: any[] = [];
+
+  // healthy-single-bp doubles as the zero-marginal LOW step.
+  const healthySub = buildSubset(fleet, drifted, { tenants: lowN, sameBpRegex });
+  warnings.push(...healthySub.warnings);
+  const healthyFleet = writeFleetFile(outDir, 'healthy', healthySub.subset);
+  steps.push({ name: 'healthy-single-bp', fleet: healthyFleet, shape: 'uniform', rps: 25, durationSec: 120 });
+
+  // zero-marginal HIGH step (only if it adds tenants over the low step).
+  let haveZmHigh = false;
+  if (maxAvail > lowN) {
+    const zmHighSub = buildSubset(fleet, drifted, { tenants: maxAvail, sameBpRegex });
+    warnings.push(...zmHighSub.warnings);
+    const zmHighFleet = writeFleetFile(outDir, 'zm-high', zmHighSub.subset);
+    steps.push({ name: 'zm-high', fleet: zmHighFleet, shape: 'zipf', rps: 25, durationSec: 120 });
+    haveZmHigh = true;
+  } else {
+    warnings.push(`zero-marginal: only ${maxAvail} single-blueprint tenants; high step == low step (delta forced 0)`);
+  }
+
+  // thrash-not-crash (standard + deep) needs multiple distinct blueprint shapes.
+  let haveThrash = false;
+  if (suite !== 'quick') {
+    try {
+      const thrashSub = buildSubset(fleet, drifted, { blueprints: 3, perBlueprint: 2, sameBpRegex });
+      warnings.push(...thrashSub.warnings);
+      const thrashFleet = writeFleetFile(outDir, 'thrash', thrashSub.subset);
+      steps.push({ name: 'thrash-not-crash', fleet: thrashFleet, shape: 'uniform', rps: 25, durationSec: 120 });
+      haveThrash = true;
+    } catch (e: any) {
+      warnings.push(`thrash-not-crash skipped: ${e.message || e} (needs --drifted with >=1 drift group)`);
+    }
+  }
+
+  const plan = {
+    port,
+    defaults: { heapMb, rps: 25, durationSec: 120, shape: 'uniform', auth: 1, mix },
+    steps
+  };
+  const planFile = path.join(outDir, 'regression-plan.json');
+  ensureParentDir(planFile);
+  fs.writeFileSync(planFile, JSON.stringify(plan, null, 2) + '\n');
+
+  // Common PG env for children (creds via env, not argv).
+  const childEnv: Record<string, string> = {
+    PGHOST: pg.host,
+    PGPORT: String(pg.port),
+    PGUSER: pg.user,
+    PGPASSWORD: pg.password,
+    PGDATABASE: pg.database
+  };
+  const passthrough: string[] = [];
+  if (allowHub) passthrough.push('--allow-hub');
+  if (typeof argv['server-cmd'] === 'string') passthrough.push('--server-cmd', argv['server-cmd']);
+
+  const measured: MeasuredRegression = {};
+
+  // --- (standard + deep) measure instance-heap -----------------------------
+  if (suite !== 'quick') {
+    const hostTenant = fleet.find((t) => t.apiHost);
+    const host = hostTenant ? hostTenant.apiHost : null;
+    if (!host) {
+      warnings.push('instance-heap skipped: no tenant with an apiHost in the fleet');
+    } else {
+      const ihOut = path.join(outDir, 'regression-instance-heap.jsonl');
+      if (fs.existsSync(ihOut)) fs.rmSync(ihOut);
+      err(`measuring instance heap on ${host} (heap ${heapMb}MB, port ${port})...`);
+      spawnCli(
+        cliEntry,
+        ['measure', 'instance-heap', '--label', 'regression-api', '--host', host, '--port', String(port), '--heap-mb', String(heapMb), '--out', ihOut, ...passthrough],
+        childEnv,
+        logFile
+      );
+      const ihRows = readJsonl(ihOut);
+      const ih = ihRows[ihRows.length - 1];
+      if (ih && typeof ih.deltaHeapMB === 'number') {
+        measured.instanceHeapKBPerRow = Math.round(((ih.deltaHeapMB * 1024) / catalogRows) * 100) / 100;
+      } else {
+        warnings.push('instance-heap produced no usable delta (see regression.log)');
+      }
+    }
+  }
+
+  // --- run ramp (all workload steps) ---------------------------------------
+  const rampOut = path.join(outDir, 'regression-ramp-results.jsonl');
+  if (fs.existsSync(rampOut)) fs.rmSync(rampOut);
+  err(`running ${steps.length} ramp step(s): ${steps.map((s) => s.name).join(', ')}...`);
+  const ramp = spawnCli(cliEntry, ['run', 'ramp', '--plan', planFile, '--out', rampOut, '--out-dir', outDir, ...passthrough], childEnv, logFile);
+  if (ramp.status !== 0) {
+    warnings.push(`run ramp exited ${ramp.status ?? `signal ${ramp.signal}`} (steps may be partial; see regression.log)`);
+  }
+
+  const rampRows = readJsonl(rampOut);
+  const byName = new Map<string, any>();
+  for (const rec of rampRows) if (rec && rec.name) byName.set(rec.name, rec);
+
+  // healthy-single-bp: errRate + p99.
+  const healthyRec = byName.get('healthy-single-bp');
+  if (healthyRec) {
+    const s = healthyRec.summary || {};
+    measured.healthy = {
+      errRate: s.errRate,
+      p99Ms: s.latency?.p99
+    };
+  } else {
+    warnings.push('healthy-single-bp: no ramp record produced');
+  }
+
+  // zero-marginal: heapMax(low) from healthy step, heapMax(high) from zm-high.
+  const lowHeap = healthyRec?.metrics?.heapUsedMaxMB;
+  const highHeap = haveZmHigh ? byName.get('zm-high')?.metrics?.heapUsedMaxMB : lowHeap;
+  if (typeof lowHeap === 'number' && typeof highHeap === 'number') {
+    measured.zeroMarginalDeltaMB = Math.round(Math.abs(highHeap - lowHeap) * 10) / 10;
+  } else {
+    warnings.push('zero-marginal: missing heapUsedMaxMB in one of the steps');
+  }
+
+  // thrash-not-crash: server must survive.
+  if (haveThrash) {
+    const thrashRec = byName.get('thrash-not-crash');
+    if (thrashRec) {
+      measured.thrashCrashed = thrashRec.serverCrashed === true;
+    } else {
+      warnings.push('thrash-not-crash: no ramp record produced');
+    }
+  }
+
+  // bleed: sentinel violations across ALL steps (+ any harness exit 2).
+  let bleed = 0;
+  for (const rec of rampRows) {
+    bleed += rec?.summary?.verdict?.bleedViolations ?? 0;
+    if (rec?.harnessExit === 2 && (rec?.summary?.verdict?.bleedViolations ?? 0) === 0) bleed += 1;
+  }
+  measured.bleedViolations = bleed;
+
+  // --- compare + verdict ----------------------------------------------------
+  const checks = compareToBaseline(measured, baseline);
+
+  // --- (deep) scenario probes ----------------------------------------------
+  // Each scenario boots its OWN fresh server(s) on the same guardrailed port
+  // (sequential, after the ramp child has released it), drives light traffic
+  // itself, and restores the rig in its own finally. Their checks are merged in
+  // BEFORE the verdict; advisory checks never flip it (see compare.ts).
+  let scenarioResults: ScenarioResult[] = [];
+  if (suite === 'deep') {
+    const ctx: ScenarioContext = {
+      suite,
+      pg,
+      port,
+      deepHeapMb,
+      heapMb,
+      outDir,
+      repoRoot,
+      serverCmd,
+      allowHub,
+      catalogRows,
+      baseline,
+      fleet,
+      drifted,
+      sameBpRegex,
+      only: onlyScenarios,
+      skip: skipScenarios,
+      creds: resolveCreds(argv)
+    };
+    err(`running deep scenarios: ${['multi-api-residency', 'settings-variant-split', 'realtime-dedicated-cost', 'partition-creep'].join(', ')}...`);
+    scenarioResults = await runDeepScenarios(ctx);
+    for (const sr of scenarioResults) {
+      checks.push(...sr.checks);
+      if (sr.warnings && sr.warnings.length) warnings.push(...sr.warnings.map((w) => `[${sr.name}] ${w}`));
+      if (sr.skipped) warnings.push(`scenario ${sr.name} skipped: ${sr.skipped}`);
+      if (sr.error) warnings.push(`scenario ${sr.name} error: ${sr.error}`);
+    }
+  }
+
+  const verdict = verdictFromChecks(checks);
+
+  const results = {
+    generatedAt: new Date().toISOString(),
+    baseline: baselineName,
+    suite,
+    port,
+    heapMb,
+    deepHeapMb,
+    catalogPgClassRows: catalogRows,
+    fleet: fleetFile,
+    measured,
+    checks,
+    scenarios: scenarioResults,
+    verdict,
+    warnings,
+    artifacts: { plan: planFile, rampResults: rampOut, log: logFile }
+  };
+  const resultsFile = path.join(outDir, 'regression-results.json');
+  ensureParentDir(resultsFile);
+  fs.writeFileSync(resultsFile, JSON.stringify(results, null, 2) + '\n');
+  err(`wrote ${resultsFile}`);
+
+  // Human verdict table (stdout). Advisory checks are tagged so it is obvious
+  // they do NOT contribute to the verdict.
+  console.log(`\n== regression ${baselineName} (${suite}) — catalog ${catalogRows} rows`);
+  for (const c of checks) {
+    const mark = c.advisory ? (c.pass ? 'ADVISORY ok' : 'ADVISORY x') : c.pass ? 'PASS' : 'FAIL';
+    console.log(`  [${mark}] ${c.name}: value=${c.value} threshold=${c.threshold}  — ${c.note}`);
+  }
+  for (const w of warnings) console.log(`  (warn) ${w}`);
+  console.log(`  verdict: ${verdict.pass ? 'PASS' : verdict.bleed ? 'BLEED' : 'FAIL'} (exit ${verdict.exitCode})`);
+
+  return verdict.exitCode;
+}
diff --git a/packages/perf-harness/src/report/__tests__/merge.test.ts b/packages/perf-harness/src/report/__tests__/merge.test.ts
new file mode 100644
index 0000000000..5a99daae66
--- /dev/null
+++ b/packages/perf-harness/src/report/__tests__/merge.test.ts
@@ -0,0 +1,164 @@
+import { mergeReport, MergeSources, parseOpsLine, renderMarkdown } from '../merge';
+
+const T0 = Date.parse('2026-07-03T00:00:00.000Z');
+const iso = (offsetSec: number): string => new Date(T0 + offsetSec * 1000).toISOString();
+const MB = 1048576;
+
+function counters(builds: number, lru: number, governor: number, absorbedExceptions: number, buildRefusals: number): any {
+  return {
+    evictions: { lru, ttl: 0, manual: 0, governor },
+    disposals: 0,
+    drainTimeouts: 0,
+    buildRefusals,
+    builds,
+    poolingAttaches: 0,
+    poolingBuilds: 0,
+    buildWaitTimeouts: 0,
+    buildQueueDepth: 0,
+    connGuard: { absorbedExceptions, absorbedRejections: 0 }
+  };
+}
+
+function sources(): MergeSources {
+  const metrics = [
+    { ts: iso(0), rss: 150 * MB, heapUsed: 60 * MB, cache: { size: 0, keys: 0 }, counters: counters(0, 0, 0, 0, 0), gc: {} },
+    { ts: iso(10), rss: 160 * MB, heapUsed: 70 * MB, cache: { size: 1, keys: 1 }, counters: counters(1, 1, 0, 0, 0), gc: {} },
+    { ts: iso(20), rss: 170 * MB, heapUsed: 80 * MB, cache: { size: 1, keys: 1 }, counters: counters(2, 2, 1, 3, 1), gc: {} },
+    { ts: iso(30), rss: 180 * MB, heapUsed: 90 * MB, cache: { size: 1, keys: 1 }, counters: counters(3, 2, 1, 5, 1), gc: {} }
+  ];
+  const harness = [
+    { hello: 'banner-non-progress-line' }, // must be filtered out
+    { t: 'progress', at: iso(5), elapsedSec: 5, windowErrRate: 0, latencyWindow: { p50: 13, p95: 21, p99: 21 }, sent: 50, completed: 50, ok: 50, err: 0 },
+    { t: 'progress', at: iso(15), elapsedSec: 15, windowErrRate: 0.01, latencyWindow: { p50: 14, p95: 22, p99: 30 }, sent: 150, completed: 150, ok: 148, err: 2 },
+    { t: 'progress', at: iso(28), elapsedSec: 28, windowErrRate: 0, latencyWindow: { p50: 13, p95: 21, p99: 25 }, sent: 280, completed: 280, ok: 278, err: 2 }
+  ];
+  const churn = [
+    { t: 'start', at: iso(1), channel: 'schema:update', tenants: 5 },
+    { t: 'notify', at: iso(12), dbname: 'factory1', databaseId: 'db-1', seq: 1 },
+    { t: 'stop', at: iso(30), reason: 'signal', notifies: 1, provisions: 0 }
+  ];
+  const ops = [
+    `[soak-ops] ${iso(2)} start: interval=7200s duration=86400s prefix=soak`,
+    `[soak-ops] ${iso(18)} cycle=1 provision status=0 created=soak5 :: some tail`,
+    `[soak-ops] ${iso(29)} cycle=1 drop soak4 status=0`
+  ];
+  const pg = [
+    { t: iso(8), docker: { usedBytes: 800 * MB, limitBytes: 4000 * MB }, backendsTotal: 12 },
+    { t: iso(22), docker: { usedBytes: 900 * MB, limitBytes: 4000 * MB }, backendsTotal: 15 }
+  ];
+  return { metrics, harness, churn, ops, pg };
+}
+
+describe('mergeReport', () => {
+  test('series arrays are all aligned to the metrics clock length', () => {
+    const rd = mergeReport(sources());
+    const s = rd.series;
+    expect(s.t).toHaveLength(4);
+    expect(s.heapUsedMB).toHaveLength(4);
+    expect(s.rssMB).toHaveLength(4);
+    expect(s.cacheSize).toHaveLength(4);
+    expect(s.windowErrRate).toHaveLength(4);
+    expect(s.p99).toHaveLength(4);
+    expect(s.pgContainerMB).toHaveLength(4);
+    expect(s.pgBackends).toHaveLength(4);
+    expect(s.t).toEqual([0, 10, 20, 30]);
+    expect(s.heapUsedMB).toEqual([60, 70, 80, 90]);
+  });
+
+  test('nearest-sample alignment pulls harness + pg values onto metrics ticks', () => {
+    const s = mergeReport(sources()).series;
+    // p99: metric@20 -> progress@15 (=30), metric@30 -> progress@28 (=25)
+    expect(s.p99[2]).toBe(30);
+    expect(s.p99[3]).toBe(25);
+    expect(s.windowErrRate[2]).toBe(0.01);
+    // pg: metric@20 -> pg@22 (900MB / 15), metric@0 -> pg@8 (800MB / 12)
+    expect(s.pgContainerMB[0]).toBe(800);
+    expect(s.pgContainerMB[3]).toBe(900);
+    expect(s.pgBackends[3]).toBe(15);
+  });
+
+  test('extracts churn + ops events sorted by time', () => {
+    const rd = mergeReport(sources());
+    expect(rd.events).toHaveLength(6); // 3 churn + 3 ops
+    const types = rd.events.map((e) => e.type);
+    expect(types).toContain('churn:start');
+    expect(types).toContain('churn:notify');
+    expect(types).toContain('churn:stop');
+    expect(types).toContain('ops:start');
+    expect(types).toContain('ops:provision');
+    expect(types).toContain('ops:drop');
+    // sorted ascending by `at`
+    const ats = rd.events.map((e) => Date.parse(e.at));
+    expect(ats).toEqual([...ats].sort((a, b) => a - b));
+    const notify = rd.events.find((e) => e.type === 'churn:notify');
+    expect(notify.detail).toContain('factory1');
+    const provision = rd.events.find((e) => e.type === 'ops:provision');
+    expect(provision.detail).toContain('cycle=1 provision');
+    // the `:: tail` suffix is trimmed off
+    expect(provision.detail).not.toContain('some tail');
+  });
+
+  test('computes counter first/last/delta', () => {
+    const rd = mergeReport(sources());
+    expect(rd.counters.delta.builds).toBe(3);
+    expect(rd.counters.delta.evictions.lru).toBe(2);
+    expect(rd.counters.delta.evictions.governor).toBe(1);
+    expect(rd.counters.delta.connGuard.absorbedExceptions).toBe(5);
+    expect(rd.counters.delta.buildRefusals).toBe(1);
+    expect(rd.counters.first.builds).toBe(0);
+    expect(rd.counters.last.builds).toBe(3);
+  });
+
+  test('heap slope is positive for a rising heap', () => {
+    const rd = mergeReport(sources());
+    // 60 -> 90 MB over 30s == 1 MB/s == 3600 MB/h
+    expect(rd.slopes.heapMBPerHourFull).toBeGreaterThan(0);
+    expect(rd.slopes.heapMBPerHourLastHalf).toBeGreaterThan(0);
+    expect(Math.round(rd.slopes.heapMBPerHourFull)).toBe(3600);
+  });
+
+  test('meta aggregates requests, latency, heap and pg maxima', () => {
+    const rd = mergeReport(sources());
+    expect(rd.meta.requests.sent).toBe(280);
+    expect(rd.meta.requests.completed).toBe(280);
+    expect(rd.meta.requests.err).toBe(2);
+    expect(rd.meta.latency.p99).toBe(30); // worst window p99
+    expect(rd.meta.latency.p50).toBe(13); // median of window p50s [13,14,13]
+    expect(rd.meta.heap.startMB).toBe(60);
+    expect(rd.meta.heap.maxMB).toBe(90);
+    expect(rd.meta.heap.finalMB).toBe(90);
+    expect(rd.meta.pgContainerMaxMB).toBe(900);
+    expect(rd.meta.counts.events).toBe(6);
+  });
+
+  test('renderMarkdown produces a table with the key rows', () => {
+    const md = renderMarkdown(mergeReport(sources()));
+    expect(md).toContain('| metric | value |');
+    expect(md).toContain('duration');
+    expect(md).toContain('| builds Δ | 3 |');
+    expect(md).toContain('| conn-guard absorbed Δ | 5 |');
+    expect(md).toContain('| pg container max | 900 MB |');
+  });
+
+  test('tolerates empty inputs without throwing', () => {
+    const rd = mergeReport({ metrics: [], harness: [] });
+    expect(rd.series.t).toHaveLength(0);
+    expect(rd.events).toHaveLength(0);
+    expect(rd.counters.delta).toBeNull();
+    expect(rd.slopes.heapMBPerHourFull).toBe(0);
+  });
+});
+
+describe('parseOpsLine', () => {
+  test('parses a provision cycle line', () => {
+    const ev = parseOpsLine('[soak-ops] 2026-07-03T00:00:18.000Z cycle=1 provision status=0 created=soak5 :: tail');
+    expect(ev.type).toBe('ops:provision');
+    expect(ev.at).toBe('2026-07-03T00:00:18.000Z');
+    expect(ev.detail).toBe('cycle=1 provision status=0 created=soak5');
+  });
+
+  test('returns null for a non-soak-ops line', () => {
+    expect(parseOpsLine('[harness] seed=42 shape=zipf')).toBeNull();
+    expect(parseOpsLine('')).toBeNull();
+  });
+});
diff --git a/packages/perf-harness/src/report/__tests__/summarize.test.ts b/packages/perf-harness/src/report/__tests__/summarize.test.ts
new file mode 100644
index 0000000000..1f5a062e76
--- /dev/null
+++ b/packages/perf-harness/src/report/__tests__/summarize.test.ts
@@ -0,0 +1,98 @@
+import { formatStepRecord } from '../summarize';
+
+describe('formatStepRecord', () => {
+  const healthy: any = {
+    name: 'rps-200',
+    serverCrashed: null,
+    error: null,
+    summary: {
+      achievedRps: 188.4,
+      completed: 79128,
+      errRate: 0,
+      latency: { count: 82000, min: 3, mean: 12, p50: 13, p95: 21, p99: 21, max: 67 },
+      http: { '200': 82000 },
+      sentinelOk: true,
+      verdict: { pass: true, bleedViolations: 0 }
+    },
+    metrics: {
+      samples: 99,
+      rssMaxMB: 2201.3,
+      heapUsedMaxMB: 1588.2,
+      heapUsedLastMB: 1500,
+      buildQueueDepthMax: 0,
+      lastCache: { size: 1, keys: 1 },
+      lastCounters: {
+        evictions: { lru: 1, ttl: 0, manual: 0, governor: 0 },
+        disposals: 0,
+        drainTimeouts: 0,
+        buildRefusals: 0,
+        builds: 2,
+        connGuard: { absorbedExceptions: 0, absorbedRejections: 0 }
+      }
+    },
+    pgBackends: { max: 5, samples: 99, err: null },
+    wallSec: 510
+  };
+
+  test('formats a healthy step with every field present', () => {
+    const line = formatStepRecord(healthy);
+    // first pipe-segment is the step name
+    expect(line.split(' | ')[0]).toBe('rps-200');
+    expect(line).toContain('crashed=false');
+    expect(line).toContain('err=-');
+    expect(line).toContain('errRate=0');
+    expect(line).toContain('rps=188.4');
+    expect(line).toContain('p50/p95/p99=13/21/21');
+    expect(line).toContain('http={"200":82000}');
+    expect(line).toContain('sentinelOk=true');
+    expect(line).toContain('heapMax=1588.2MB');
+    expect(line).toContain('rssMax=2201.3MB');
+    expect(line).toContain('queueMax=0');
+    expect(line).toContain('evict={"lru":1,"ttl":0,"manual":0,"governor":0}');
+    expect(line).toContain('builds=2');
+    expect(line).toContain('connGuard={"absorbedExceptions":0,"absorbedRejections":0}');
+    expect(line).toContain('pgConnMax=5');
+    expect(line).toContain('wall=510s');
+    // no cold-burst blob for a normal step
+    expect(line).not.toContain('cold=');
+  });
+
+  test('renders a crashed step with the serialized exit', () => {
+    const crashed: any = {
+      name: 'div-k1',
+      serverCrashed: true,
+      serverExit: { code: null, signal: 'SIGABRT' },
+      error: null,
+      wallSec: 40
+    };
+    const line = formatStepRecord(crashed);
+    expect(line).toContain('crashed={"code":null,"signal":"SIGABRT"}');
+    expect(line).toContain('wall=40s');
+    // absent summary/metrics fields are simply omitted
+    expect(line).not.toContain('errRate=');
+    expect(line).not.toContain('heapMax=');
+  });
+
+  test('emits the cold-burst summary blob when coldBurst is present', () => {
+    const cold: any = {
+      name: 'cold-burst',
+      serverCrashed: null,
+      error: null,
+      coldBurst: { wave1: [], wave2: [] },
+      summary: { coldOk: 0, cold503: 0, coldErr: 5, coldMsMax: 6841, warmMsMax: 58 },
+      wallSec: 120
+    };
+    const line = formatStepRecord(cold);
+    expect(line).toContain('cold=');
+    expect(line).toContain('"coldErr":5');
+    expect(line).toContain('wall=120s');
+  });
+
+  test('shows reconnects on pgBackends only when non-zero', () => {
+    const withReconn = formatStepRecord({ name: 'x', pgBackends: { max: 7, reconnects: 3 }, wallSec: 1 });
+    expect(withReconn).toContain('pgConnMax=7 reconn=3');
+    const noReconn = formatStepRecord({ name: 'x', pgBackends: { max: 7, reconnects: 0 }, wallSec: 1 });
+    expect(noReconn).toContain('pgConnMax=7');
+    expect(noReconn).not.toContain('reconn=');
+  });
+});
diff --git a/packages/perf-harness/src/report/merge.ts b/packages/perf-harness/src/report/merge.ts
new file mode 100644
index 0000000000..dcdd079fbf
--- /dev/null
+++ b/packages/perf-harness/src/report/merge.ts
@@ -0,0 +1,387 @@
+/**
+ * report merge — fuse the artifacts of one perf run into a single report.
+ *
+ * A soak (or ramp) leaves four independent time series behind, each on its own
+ * clock and cadence:
+ *   --metrics     server GRAPHILE_DEBUG_METRICS JSONL (rss/heap/cache/counters/gc)
+ *   --harness-log harness stdout JSONL (t:"progress" windows: rps/errRate/latency)
+ *   --churn-log   churn-driver stdout JSONL (start/notify/provision-marker/stop)
+ *   --ops-log     soak-ops stdout TEXT ([soak-ops] <iso> cycle=N provision|drop ...)
+ *   --pg          pg-sampler JSONL (docker mem + pg_stat_activity backends)
+ *
+ * `merge` aligns them onto the server-metrics clock (nearest-sample hold),
+ * extracts churn/ops timeline events, computes counter first/last/delta and the
+ * heap-growth slope (full run + last half), and writes `report-data.json`. A
+ * compact markdown summary table is printed to stdout for eyeballing.
+ *
+ * The alignment + aggregation live in the pure `mergeReport(sources)` so tests
+ * can drive it from small in-memory fixtures.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv } from '../core/args';
+import { resolveOutDir } from '../core/config';
+import { ensureParentDir, readJsonl } from '../core/proc';
+import { linregSlope } from '../measure/collector';
+
+const USAGE = `perf-harness report merge --metrics <metrics.jsonl> --harness-log <harness.jsonl> \\
+  [--churn-log <churn.jsonl>] [--ops-log <soak-ops.log>] [--pg <pg.jsonl>] [--out-dir ./perf-out]
+
+Fuse server metrics + harness progress + churn/ops events + pg-sampler into
+report-data.json (aligned series, events, counter deltas, heap slope) and print
+a markdown summary.`;
+
+const MB = (b: number): number => Math.round((b / 1048576) * 10) / 10;
+const r2 = (x: number): number => Math.round(x * 100) / 100;
+const nowIso = (): string => new Date().toISOString();
+const ms = (iso: string): number => Date.parse(iso);
+
+export interface MergeSources {
+  metrics: any[];
+  harness: any[]; // raw harness stdout objects; progress lines are filtered here
+  churn?: any[];
+  ops?: string[]; // raw text lines from the soak-ops stdout log
+  pg?: any[];
+  sourcePaths?: Record<string, string | null>;
+}
+
+export interface ReportEvent {
+  at: string;
+  type: string;
+  detail: string;
+}
+
+export interface ReportData {
+  meta: any;
+  series: {
+    t: number[];
+    heapUsedMB: number[];
+    rssMB: number[];
+    cacheSize: number[];
+    windowErrRate: number[];
+    p99: number[];
+    pgContainerMB: number[];
+    pgBackends: number[];
+  };
+  events: ReportEvent[];
+  counters: { first: any; last: any; delta: any };
+  slopes: { heapMBPerHourFull: number; heapMBPerHourLastHalf: number };
+}
+
+// ---------------------------------------------------------------------------
+// event extraction
+// ---------------------------------------------------------------------------
+
+function churnEvents(churn: any[]): ReportEvent[] {
+  const out: ReportEvent[] = [];
+  for (const e of churn || []) {
+    if (!e || !e.at) continue;
+    switch (e.t) {
+      case 'start':
+        out.push({ at: e.at, type: 'churn:start', detail: `channel=${e.channel} tenants=${e.tenants}` });
+        break;
+      case 'notify':
+        out.push({ at: e.at, type: 'churn:notify', detail: `db=${e.dbname ?? e.databaseId} seq=${e.seq}` });
+        break;
+      case 'notify-error':
+        out.push({ at: e.at, type: 'churn:notify-error', detail: `db=${e.dbname ?? e.databaseId} ${e.error || ''}`.trim() });
+        break;
+      case 'provision-marker':
+        out.push({ at: e.at, type: 'churn:provision-marker', detail: `seq=${e.seq}` });
+        break;
+      case 'stop':
+        out.push({ at: e.at, type: 'churn:stop', detail: `reason=${e.reason} notifies=${e.notifies} provisions=${e.provisions}` });
+        break;
+      default:
+        break;
+    }
+  }
+  return out;
+}
+
+// soak-ops lines are plain text: `[soak-ops] <iso> <body>`. Parse leniently.
+export function parseOpsLine(line: string): ReportEvent | null {
+  const m = /^\[soak-ops\]\s+(\S+)\s+(.+)$/.exec(line.trim());
+  if (!m) return null;
+  const at = m[1];
+  const body = m[2].trim();
+  let type = 'ops:other';
+  if (/^start\b/.test(body)) type = 'ops:start';
+  else if (/^cycle=\d+\s+provision\b/.test(body)) type = 'ops:provision';
+  else if (/^cycle=\d+\s+drop\b/.test(body)) type = 'ops:drop';
+  else if (/^final cleanup\b/.test(body)) type = 'ops:cleanup';
+  else if (/^done\b/.test(body)) type = 'ops:done';
+  // Trim the noisy `:: <tail>` suffix and cap length.
+  const detail = body.split(' :: ')[0].slice(0, 200);
+  return { at, type, detail };
+}
+
+function opsEvents(ops: string[]): ReportEvent[] {
+  const out: ReportEvent[] = [];
+  for (const line of ops || []) {
+    if (!line || !line.trim()) continue;
+    const ev = parseOpsLine(line);
+    if (ev) out.push(ev);
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// nearest-sample alignment (sample-and-hold onto the metrics clock)
+// ---------------------------------------------------------------------------
+
+// Index of the source sample whose time is closest to target `t`.
+function nearestIndex(sortedTimes: number[], t: number): number {
+  const n = sortedTimes.length;
+  if (n === 0) return -1;
+  let lo = 0;
+  let hi = n - 1;
+  if (t <= sortedTimes[0]) return 0;
+  if (t >= sortedTimes[n - 1]) return n - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (sortedTimes[mid] === t) return mid;
+    if (sortedTimes[mid] < t) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  // lo is the first index with time > t; hi = lo - 1.
+  const after = lo;
+  const before = hi;
+  return t - sortedTimes[before] <= sortedTimes[after] - t ? before : after;
+}
+
+// ---------------------------------------------------------------------------
+// counter deltas (recursive numeric diff)
+// ---------------------------------------------------------------------------
+
+export function numericDelta(a: any, b: any): any {
+  if (typeof b === 'number') return typeof a === 'number' ? b - a : b;
+  if (b && typeof b === 'object') {
+    const out: any = {};
+    const keys = new Set<string>([...Object.keys(a || {}), ...Object.keys(b)]);
+    for (const k of keys) out[k] = numericDelta((a || {})[k], b[k]);
+    return out;
+  }
+  return b;
+}
+
+// ---------------------------------------------------------------------------
+// main merge
+// ---------------------------------------------------------------------------
+
+export function mergeReport(sources: MergeSources): ReportData {
+  const metrics = (sources.metrics || []).filter((x) => x && x.ts).slice().sort((a, b) => ms(a.ts) - ms(b.ts));
+  const progress = (sources.harness || []).filter((x) => x && x.t === 'progress' && x.at).slice().sort((a, b) => ms(a.at) - ms(b.at));
+  const pg = (sources.pg || []).filter((x) => x && x.t).slice().sort((a, b) => ms(a.t) - ms(b.t));
+
+  const events = [...churnEvents(sources.churn || []), ...opsEvents(sources.ops || [])].sort(
+    (a, b) => ms(a.at) - ms(b.at)
+  );
+
+  const progressTimes = progress.map((p) => ms(p.at));
+  const pgTimes = pg.map((p) => ms(p.t));
+
+  const series = {
+    t: [] as number[],
+    heapUsedMB: [] as number[],
+    rssMB: [] as number[],
+    cacheSize: [] as number[],
+    windowErrRate: [] as number[],
+    p99: [] as number[],
+    pgContainerMB: [] as number[],
+    pgBackends: [] as number[]
+  };
+
+  const t0 = metrics.length ? ms(metrics[0].ts) : (progressTimes[0] ?? pgTimes[0] ?? Date.now());
+
+  for (const mline of metrics) {
+    const t = ms(mline.ts);
+    series.t.push(r2((t - t0) / 1000));
+    series.heapUsedMB.push(MB(mline.heapUsed));
+    series.rssMB.push(MB(mline.rss));
+    series.cacheSize.push(mline.cache?.size ?? null);
+
+    const pi = nearestIndex(progressTimes, t);
+    if (pi >= 0) {
+      series.windowErrRate.push(progress[pi].windowErrRate ?? null);
+      series.p99.push(progress[pi].latencyWindow?.p99 ?? null);
+    } else {
+      series.windowErrRate.push(null);
+      series.p99.push(null);
+    }
+
+    const gi = nearestIndex(pgTimes, t);
+    if (gi >= 0) {
+      const used = pg[gi].docker?.usedBytes;
+      series.pgContainerMB.push(typeof used === 'number' ? MB(used) : null);
+      series.pgBackends.push(pg[gi].backendsTotal ?? null);
+    } else {
+      series.pgContainerMB.push(null);
+      series.pgBackends.push(null);
+    }
+  }
+
+  // Counter first/last/delta.
+  const firstCounters = metrics.length ? metrics[0].counters ?? null : null;
+  const lastCounters = metrics.length ? metrics[metrics.length - 1].counters ?? null : null;
+  const delta = firstCounters && lastCounters ? numericDelta(firstCounters, lastCounters) : null;
+
+  // Heap-growth slope (MB/hour) over the full run and the last half.
+  const heapPoints: [number, number][] = metrics.map((m) => [(ms(m.ts) - t0) / 1000, MB(m.heapUsed)]);
+  const half = heapPoints.slice(Math.floor(heapPoints.length / 2));
+  const slopes = {
+    heapMBPerHourFull: r2(linregSlope(heapPoints) * 3600),
+    heapMBPerHourLastHalf: r2(linregSlope(half) * 3600)
+  };
+
+  // Requests + errRate from the final progress window (sent/completed/ok/err
+  // are cumulative in a progress line; windowRps/windowErrRate are per-window).
+  const lastProg = progress.length ? progress[progress.length - 1] : null;
+  const requests = lastProg
+    ? {
+        sent: lastProg.sent ?? null,
+        completed: lastProg.completed ?? null,
+        ok: lastProg.ok ?? null,
+        err: lastProg.err ?? null,
+        errRate: lastProg.completed ? r2((lastProg.err || 0) / lastProg.completed) : 0
+      }
+    : { sent: null, completed: null, ok: null, err: null, errRate: null };
+
+  // Aggregate latency: typical median (median of window p50s) + worst tail
+  // (max window p99). Windowed data has no raw samples for a true overall pctl.
+  const p50s = progress.map((p) => p.latencyWindow?.p50).filter((v) => typeof v === 'number');
+  const p99s = progress.map((p) => p.latencyWindow?.p99).filter((v) => typeof v === 'number');
+  const median = (arr: number[]): number => {
+    if (!arr.length) return null;
+    const s = arr.slice().sort((a, b) => a - b);
+    const mid = Math.floor(s.length / 2);
+    return s.length % 2 ? s[mid] : r2((s[mid - 1] + s[mid]) / 2);
+  };
+  const latency = { p50: median(p50s), p99: p99s.length ? Math.max(...p99s) : null };
+
+  const startedAt = metrics.length ? metrics[0].ts : lastProg ? progress[0].at : null;
+  const endedAt = metrics.length ? metrics[metrics.length - 1].ts : lastProg ? lastProg.at : null;
+  const durationSec = lastProg?.elapsedSec ?? (metrics.length ? r2((ms(endedAt) - t0) / 1000) : null);
+
+  const heapMBs = series.heapUsedMB;
+  const heap = {
+    startMB: heapMBs.length ? heapMBs[0] : null,
+    maxMB: heapMBs.length ? Math.max(...heapMBs) : null,
+    finalMB: heapMBs.length ? heapMBs[heapMBs.length - 1] : null
+  };
+
+  const pgContainerMaxMB = series.pgContainerMB.filter((v) => typeof v === 'number').length
+    ? Math.max(...(series.pgContainerMB.filter((v) => typeof v === 'number') as number[]))
+    : null;
+
+  const meta = {
+    generatedAt: nowIso(),
+    sources: sources.sourcePaths || {},
+    counts: {
+      metricsSamples: metrics.length,
+      harnessProgress: progress.length,
+      churnEvents: (sources.churn || []).length,
+      opsLines: (sources.ops || []).length,
+      pgSamples: pg.length,
+      events: events.length
+    },
+    startedAt,
+    endedAt,
+    durationSec,
+    requests,
+    latency,
+    heap,
+    pgContainerMaxMB
+  };
+
+  return { meta, series, events, counters: { first: firstCounters, last: lastCounters, delta }, slopes };
+}
+
+// ---------------------------------------------------------------------------
+// markdown summary
+// ---------------------------------------------------------------------------
+
+export function renderMarkdown(rd: ReportData): string {
+  const m = rd.meta;
+  const d = rd.counters.delta || {};
+  const ev = d.evictions || {};
+  const evictionsDelta = (ev.lru || 0) + (ev.ttl || 0) + (ev.manual || 0) + (ev.governor || 0);
+  const governorDelta = ev.governor || 0;
+  const buildsDelta = d.builds || 0;
+  const refusalsDelta = d.buildRefusals || 0;
+  const guardDelta = (d.connGuard?.absorbedExceptions || 0) + (d.connGuard?.absorbedRejections || 0);
+  const req = m.requests || {};
+  const heap = m.heap || {};
+  const lat = m.latency || {};
+
+  const rows: [string, string][] = [
+    ['duration', m.durationSec != null ? `${m.durationSec}s` : '-'],
+    ['requests', req.sent != null ? `${req.sent} sent / ${req.completed} done (ok ${req.ok} / err ${req.err})` : '-'],
+    ['errRate', req.errRate != null ? String(req.errRate) : '-'],
+    ['latency p50 / p99', `${lat.p50 ?? '-'} / ${lat.p99 ?? '-'} ms`],
+    ['heap start / max / final', `${heap.startMB ?? '-'} / ${heap.maxMB ?? '-'} / ${heap.finalMB ?? '-'} MB`],
+    ['heap slope full / lastHalf', `${rd.slopes.heapMBPerHourFull} / ${rd.slopes.heapMBPerHourLastHalf} MB/h`],
+    ['evictions Δ', String(evictionsDelta)],
+    ['builds Δ', String(buildsDelta)],
+    ['governor evictions Δ', String(governorDelta)],
+    ['conn-guard absorbed Δ', String(guardDelta)],
+    ['build refusals Δ', String(refusalsDelta)],
+    ['pg container max', m.pgContainerMaxMB != null ? `${m.pgContainerMaxMB} MB` : '-'],
+    ['events', String((rd.events || []).length)]
+  ];
+
+  const lines = ['| metric | value |', '| --- | --- |'];
+  for (const [k, v] of rows) lines.push(`| ${k} | ${v} |`);
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+export async function runMerge(argv: Argv): Promise<number> {
+  const metricsFile = typeof argv.metrics === 'string' ? argv.metrics : null;
+  const harnessFile = typeof argv['harness-log'] === 'string' ? argv['harness-log'] : null;
+  if (!metricsFile || !harnessFile) {
+    console.error(USAGE);
+    return 1;
+  }
+  const churnFile = typeof argv['churn-log'] === 'string' ? argv['churn-log'] : null;
+  const opsFile = typeof argv['ops-log'] === 'string' ? argv['ops-log'] : null;
+  const pgFile = typeof argv.pg === 'string' ? argv.pg : null;
+  const outDir = resolveOutDir(argv);
+
+  const sources: MergeSources = {
+    metrics: readJsonl(metricsFile),
+    harness: readJsonl(harnessFile),
+    churn: churnFile ? readJsonl(churnFile) : [],
+    ops: opsFile ? readTextLines(opsFile) : [],
+    pg: pgFile ? readJsonl(pgFile) : [],
+    sourcePaths: {
+      metrics: metricsFile,
+      harnessLog: harnessFile,
+      churnLog: churnFile,
+      opsLog: opsFile,
+      pg: pgFile
+    }
+  };
+
+  const rd = mergeReport(sources);
+  const outFile = path.join(outDir, 'report-data.json');
+  ensureParentDir(outFile);
+  fs.writeFileSync(outFile, JSON.stringify(rd, null, 2) + '\n');
+
+  // Machine artifact path to stderr; the human summary table to stdout.
+  console.error(`[merge] wrote ${outFile}`);
+  console.log(renderMarkdown(rd));
+  return 0;
+}
+
+function readTextLines(file: string): string[] {
+  try {
+    return fs.readFileSync(file, 'utf8').split('\n');
+  } catch {
+    return [];
+  }
+}
diff --git a/packages/perf-harness/src/report/predict.ts b/packages/perf-harness/src/report/predict.ts
new file mode 100644
index 0000000000..374d4d4a83
--- /dev/null
+++ b/packages/perf-harness/src/report/predict.ts
@@ -0,0 +1,99 @@
+/**
+ * report predict — capacity / sizing table.
+ *
+ * Given a per-instance retained-heap estimate (bytes) and a list of heap sizes
+ * (`--max-old-space-size` MB values), print how many PostGraphile instances a
+ * node of each size can safely keep resident (capacity R), using the SAME
+ * two-constraint budget math the server ships with — `computeCapacityFromBudget`
+ * from `graphile-cache`.
+ *
+ * `graphile-cache` is a workspace dependency, but importing it at module top
+ * level drags the whole PostGraphile build chain into every `perf-harness`
+ * start. It is therefore `require`d LAZILY inside `runPredict`, typed against a
+ * minimal local declaration rather than the real module.
+ */
+import { Argv, asInt } from '../core/args';
+
+// Server defaults (graphile-cache DEFAULT_BASE_RESERVE_BYTES / _BUILD_RESERVE_BYTES).
+const DEFAULT_BASE_RESERVE_BYTES = 256 * 1024 * 1024;
+const DEFAULT_BUILD_RESERVE_BYTES = 768 * 1024 * 1024;
+const MB = 1024 * 1024;
+
+const USAGE = `perf-harness report predict --instance-heap-bytes <n> [--heap-mb 1536,2048,3584] \\
+  [--base-reserve-bytes <n>] [--build-reserve-bytes <n>]
+
+Print a heapMB -> capacity(R) sizing table using the server's two-constraint
+budget model (graphile-cache computeCapacityFromBudget).`;
+
+// Minimal local shape of the lazily-required dependency (see file header).
+interface GraphileCacheModule {
+  computeCapacityFromBudget(
+    heapLimit: number,
+    perInstance: number,
+    baseReserve?: number,
+    buildReserve?: number
+  ): number;
+}
+
+export interface SizingRow {
+  heapMB: number;
+  heapBytes: number;
+  capacity: number;
+}
+
+// Pure table builder — `compute` is injected so this is testable without the
+// heavy workspace dependency.
+export function buildSizingTable(
+  heapMbList: number[],
+  instanceHeapBytes: number,
+  baseReserve: number,
+  buildReserve: number,
+  compute: GraphileCacheModule['computeCapacityFromBudget']
+): SizingRow[] {
+  return heapMbList.map((heapMB) => {
+    const heapBytes = heapMB * MB;
+    return { heapMB, heapBytes, capacity: compute(heapBytes, instanceHeapBytes, baseReserve, buildReserve) };
+  });
+}
+
+export async function runPredict(argv: Argv): Promise<number> {
+  const instanceHeapBytes = asInt(argv['instance-heap-bytes'], undefined);
+  if (!instanceHeapBytes || instanceHeapBytes <= 0) {
+    console.error('report predict: --instance-heap-bytes <n> is required (measured per-instance retained heap)');
+    console.error(USAGE);
+    return 1;
+  }
+  const heapMbRaw = typeof argv['heap-mb'] === 'string' ? argv['heap-mb'] : String(argv['heap-mb'] ?? '');
+  const heapMbList = heapMbRaw
+    .split(',')
+    .map((s) => Number.parseInt(s.trim(), 10))
+    .filter((n) => Number.isFinite(n) && n > 0);
+  if (heapMbList.length === 0) {
+    heapMbList.push(1536, 2048, 2560, 3072, 3584, 4096);
+  }
+  const baseReserve = asInt(argv['base-reserve-bytes'], DEFAULT_BASE_RESERVE_BYTES);
+  const buildReserve = asInt(argv['build-reserve-bytes'], DEFAULT_BUILD_RESERVE_BYTES);
+
+  // Lazy — top-level import is FORBIDDEN (drags PostGraphile into CLI start).
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const gc = require('graphile-cache') as GraphileCacheModule;
+
+  const rows = buildSizingTable(heapMbList, instanceHeapBytes, baseReserve, buildReserve, gc.computeCapacityFromBudget);
+
+  console.log(
+    `# capacity sizing  (I=${(instanceHeapBytes / MB).toFixed(0)}MB/instance, ` +
+      `base=${(baseReserve / MB).toFixed(0)}MB, build=${(buildReserve / MB).toFixed(0)}MB)`
+  );
+  console.log('| heapMB | capacity R |');
+  console.log('| --- | --- |');
+  for (const row of rows) {
+    console.log(`| ${row.heapMB} | ${row.capacity} |`);
+  }
+  console.log(
+    '\nNote: heapMB is the --max-old-space-size value. V8 reports a heap_size_limit ' +
+      'slightly ABOVE it (~3-5%, e.g. 3584 -> ~3777MB), so the server may compute a ' +
+      'marginally more generous capacity at exact boundaries; this table is the ' +
+      'conservative floor.'
+  );
+  return 0;
+}
diff --git a/packages/perf-harness/src/report/summarize.ts b/packages/perf-harness/src/report/summarize.ts
new file mode 100644
index 0000000000..5f99b69c86
--- /dev/null
+++ b/packages/perf-harness/src/report/summarize.ts
@@ -0,0 +1,83 @@
+/**
+ * report summarize — one line per ramp step record.
+ *
+ * Port of `scripts/scale-validate/summarize-results.mjs`. Reads one or more
+ * `*-results.jsonl` files (each line is a `run ramp` step record) and prints a
+ * compact single-line digest per step: crash state, error rate, achieved rps,
+ * latency percentiles, HTTP code histogram, bleed-sentinel status, heap/rss
+ * maxima, build-queue depth, eviction/build counters, connection-guard counts,
+ * peak PG backends, and wall time.
+ *
+ * `formatStepRecord` is exported so a fixture test can assert the exact field
+ * formatting without touching the filesystem.
+ */
+import fs from 'node:fs';
+
+import { Argv } from '../core/args';
+
+const USAGE = `perf-harness report summarize <results.jsonl> [more.jsonl ...]
+
+Summarize run-ramp step-result JSONL files (one digest line per step).`;
+
+// Format a single step record into the pipe-joined digest line (no indent —
+// callers add their own). Verbatim field set + ordering from the original.
+export function formatStepRecord(r: any): string {
+  const s = r.summary || {};
+  const lat = s.latency || {};
+  const m = r.metrics || {};
+  const c = m.lastCounters || {};
+  return [
+    r.name,
+    `crashed=${r.serverCrashed ? JSON.stringify(r.serverExit) : false}`,
+    `err=${r.error || '-'}`,
+    s.errRate !== undefined ? `errRate=${s.errRate}` : null,
+    s.achievedRps !== undefined ? `rps=${s.achievedRps}` : null,
+    lat.p50 !== undefined ? `p50/p95/p99=${lat.p50}/${lat.p95}/${lat.p99}` : null,
+    s.http ? `http=${JSON.stringify(s.http)}` : null,
+    s.sentinelOk !== undefined ? `sentinelOk=${s.sentinelOk}` : null,
+    r.coldBurst ? `cold=${JSON.stringify(s)}` : null,
+    m.heapUsedMaxMB !== undefined ? `heapMax=${m.heapUsedMaxMB}MB` : null,
+    m.rssMaxMB !== undefined ? `rssMax=${m.rssMaxMB}MB` : null,
+    m.buildQueueDepthMax !== undefined ? `queueMax=${m.buildQueueDepthMax}` : null,
+    c.evictions ? `evict=${JSON.stringify(c.evictions)}` : null,
+    c.builds !== undefined ? `builds=${c.builds}` : null,
+    c.connGuard ? `connGuard=${JSON.stringify(c.connGuard)}` : null,
+    r.pgBackends
+      ? `pgConnMax=${r.pgBackends.max}${r.pgBackends.reconnects ? ` reconn=${r.pgBackends.reconnects}` : ''}`
+      : null,
+    `wall=${r.wallSec}s`
+  ]
+    .filter(Boolean)
+    .join(' | ');
+}
+
+export async function runSummarize(argv: Argv): Promise<number> {
+  // Positionals are the result files. Depending on how the top-level router
+  // populates `_`, the leading routing tokens may or may not have been sliced
+  // off — drop them defensively so `report summarize a.jsonl` works either way
+  // (a real results-file path is never literally 'report'/'summarize').
+  const files = (argv._ || []).slice();
+  while (files.length && (files[0] === 'report' || files[0] === 'summarize')) files.shift();
+  if (files.length === 0) {
+    console.error(USAGE);
+    return 1;
+  }
+  for (const file of files) {
+    if (!fs.existsSync(file)) {
+      console.log(`-- ${file}: missing`);
+      continue;
+    }
+    console.log(`== ${file}`);
+    const lines = fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean);
+    for (const line of lines) {
+      let r: any;
+      try {
+        r = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      console.log('  ' + formatStepRecord(r));
+    }
+  }
+  return 0;
+}
diff --git a/packages/perf-harness/src/run/__tests__/ramp.test.ts b/packages/perf-harness/src/run/__tests__/ramp.test.ts
new file mode 100644
index 0000000000..5f26f371a9
--- /dev/null
+++ b/packages/perf-harness/src/run/__tests__/ramp.test.ts
@@ -0,0 +1,48 @@
+import { mergeStepConfig } from '../ramp';
+
+describe('mergeStepConfig', () => {
+  test('step fields override plan defaults; unspecified defaults survive', () => {
+    const defaults = {
+      heapMb: 2048,
+      rps: 10,
+      durationSec: 420,
+      shape: 'uniform',
+      auth: 1,
+      mix: 'read:0.7,write:0.25,meta:0.05'
+    };
+    const step = { name: 'div-k3', fleet: 'out/fleet-k3.json', rps: 25 };
+    const cfg = mergeStepConfig(defaults, step);
+
+    expect(cfg.rps).toBe(25); // step wins
+    expect(cfg.heapMb).toBe(2048); // default survives
+    expect(cfg.shape).toBe('uniform');
+    expect(cfg.mix).toBe('read:0.7,write:0.25,meta:0.05');
+    expect(cfg.name).toBe('div-k3'); // step-only field present
+    expect(cfg.fleet).toBe('out/fleet-k3.json');
+  });
+
+  test('does not mutate defaults or step', () => {
+    const defaults = { heapMb: 2048, rps: 10 };
+    const step = { name: 'x', rps: 25 };
+    mergeStepConfig(defaults, step);
+    expect(defaults).toEqual({ heapMb: 2048, rps: 10 });
+    expect(step).toEqual({ name: 'x', rps: 25 });
+  });
+
+  test('coldBurst flag and heapMb override flow through', () => {
+    const cfg = mergeStepConfig({ heapMb: 2048, rps: 10 }, { name: 'cb', fleet: 'f.json', coldBurst: true, heapMb: 896 });
+    expect(cfg.coldBurst).toBe(true);
+    expect(cfg.heapMb).toBe(896); // step overrides
+    expect(cfg.rps).toBe(10); // default survives
+  });
+
+  test('an empty step yields the defaults verbatim (plus its name)', () => {
+    const defaults = { heapMb: 2048, rps: 10, shape: 'zipf' };
+    expect(mergeStepConfig(defaults, { name: 'only-name' })).toEqual({ heapMb: 2048, rps: 10, shape: 'zipf', name: 'only-name' });
+  });
+
+  test('nested serverEnv from the step replaces (does not deep-merge) the default', () => {
+    const cfg = mergeStepConfig({ serverEnv: { A: '1' } }, { name: 's', serverEnv: { B: '2' } });
+    expect(cfg.serverEnv).toEqual({ B: '2' }); // shallow spread — step wins wholesale
+  });
+});
diff --git a/packages/perf-harness/src/run/__tests__/soak.test.ts b/packages/perf-harness/src/run/__tests__/soak.test.ts
new file mode 100644
index 0000000000..b8362d4884
--- /dev/null
+++ b/packages/perf-harness/src/run/__tests__/soak.test.ts
@@ -0,0 +1,20 @@
+import { SOAK_STOP_ORDER } from '../soak';
+
+describe('SOAK_STOP_ORDER', () => {
+  test('is the exact ordered fan-out from the DESIGN contract', () => {
+    expect(SOAK_STOP_ORDER).toEqual(['harness', 'collector', 'churn', 'soak-ops', 'pg-sampler', 'server']);
+  });
+
+  test('the harness is stopped first (so it flushes its final report before the server dies)', () => {
+    expect(SOAK_STOP_ORDER[0]).toBe('harness');
+  });
+
+  test('the server is stopped last (load components flush against a live server)', () => {
+    expect(SOAK_STOP_ORDER[SOAK_STOP_ORDER.length - 1]).toBe('server');
+  });
+
+  test('covers every soak component exactly once', () => {
+    expect([...SOAK_STOP_ORDER].sort()).toEqual(['churn', 'collector', 'harness', 'pg-sampler', 'server', 'soak-ops']);
+    expect(new Set(SOAK_STOP_ORDER).size).toBe(SOAK_STOP_ORDER.length);
+  });
+});
diff --git a/packages/perf-harness/src/run/__tests__/soakOps.test.ts b/packages/perf-harness/src/run/__tests__/soakOps.test.ts
new file mode 100644
index 0000000000..a1a779856c
--- /dev/null
+++ b/packages/perf-harness/src/run/__tests__/soakOps.test.ts
@@ -0,0 +1,55 @@
+import { computeCycleTiming, recoverCreatedName } from '../soakOps';
+
+describe('computeCycleTiming', () => {
+  test('waits the remaining interval when a cycle finishes early', () => {
+    const now = 1_000_000;
+    const t = computeCycleTiming({ intervalSec: 7200, elapsedMs: 5000, now, deadline: now + 100_000_000 });
+    expect(t.waitMs).toBe(7200 * 1000 - 5000);
+    expect(t.stop).toBe(false);
+  });
+
+  test('never waits a negative amount when a cycle overran the interval', () => {
+    const now = 1_000_000;
+    const t = computeCycleTiming({ intervalSec: 60, elapsedMs: 95_000, now, deadline: now + 10_000_000 });
+    expect(t.waitMs).toBe(0);
+    expect(t.stop).toBe(false);
+  });
+
+  test('signals stop when the wait would reach or cross the deadline', () => {
+    const now = 1_000_000;
+    // Only 1s left, but a full interval wait is required -> stop.
+    const t = computeCycleTiming({ intervalSec: 7200, elapsedMs: 0, now, deadline: now + 1000 });
+    expect(t.stop).toBe(true);
+  });
+
+  test('stop is inclusive at the deadline boundary (>=)', () => {
+    const now = 1_000_000;
+    const waitMs = 7200 * 1000;
+    // now + waitMs === deadline exactly -> the original breaks (>=).
+    expect(computeCycleTiming({ intervalSec: 7200, elapsedMs: 0, now, deadline: now + waitMs }).stop).toBe(true);
+    // one ms of slack -> keep going.
+    expect(computeCycleTiming({ intervalSec: 7200, elapsedMs: 0, now, deadline: now + waitMs + 1 }).stop).toBe(false);
+  });
+});
+
+describe('recoverCreatedName', () => {
+  test('recovers a name from the "[name] OK db=" marker', () => {
+    expect(recoverCreatedName('noise\n[soak7] OK db=marketplace_db_soak7 host=api-...\n', 'soak')).toBe('soak7');
+  });
+
+  test('prefixes a bare index from the "indices=N.." marker', () => {
+    expect(recoverCreatedName('provisioning indices=7.. and more', 'soak')).toBe('soak7');
+  });
+
+  test('a name already carrying the prefix is used as-is', () => {
+    expect(recoverCreatedName('[soak12] OK db=x', 'soak')).toBe('soak12');
+  });
+
+  test('prefers the "[name] OK db=" marker over the indices marker', () => {
+    expect(recoverCreatedName('indices=3.. then [soak9] OK db=y', 'soak')).toBe('soak9');
+  });
+
+  test('returns null when no marker is present', () => {
+    expect(recoverCreatedName('nothing useful here', 'soak')).toBeNull();
+  });
+});
diff --git a/packages/perf-harness/src/run/ramp.ts b/packages/perf-harness/src/run/ramp.ts
new file mode 100644
index 0000000000..1f2f6191d6
--- /dev/null
+++ b/packages/perf-harness/src/run/ramp.ts
@@ -0,0 +1,376 @@
+/**
+ * `run ramp` — V2 limits-discovery executor (port of v2-ramps.mjs).
+ *
+ * Runs a plan of ramp steps. Each step gets a FRESH server (clean cache, fresh
+ * cumulative counters, own metrics file), then either:
+ *   - drives the workload harness (`load harness`, spawned as a child of THIS
+ *     CLI) against a fleet manifest, or
+ *   - fires a cold-burst: one concurrent first-hit per tenant in the manifest
+ *     (use a 1-tenant-per-blueprint subset so every request is a cold build),
+ *     then a second warm wave.
+ *
+ * Per step it records: harness latency/error summary, metrics-file maxima
+ * (rss/heapUsed/buildQueueDepth), final cache+build counters, max PG backend
+ * count during the run, and whether the server crashed. A heap OOM is a
+ * legitimate FINDING, not a script failure — the step is recorded and the plan
+ * continues.
+ *
+ * Plan file:
+ *   { "port": 3345,
+ *     "defaults": { "heapMb": 2048, "rps": 10, "durationSec": 420,
+ *                   "shape": "uniform", "auth": 1, "mix": "read:0.7,write:0.25,meta:0.05" },
+ *     "steps": [ { "name": "div-k3", "fleet": "out/fleet-k3.json" },
+ *                { "name": "cold-burst", "fleet": "out/fleet-burst.json", "coldBurst": true } ] }
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv, asBool, asInt } from '../core/args';
+import { assertPortAllowed, findRepoRoot, PgConfig, pgConfigFromArgv, resolveOutDir, resolveServerCmd } from '../core/config';
+import { loadFleet, Tenant } from '../core/fleetfile';
+import { getPg } from '../core/pgc';
+import { ensureParentDir, readJsonl } from '../core/proc';
+import { spawnServer, SpawnedServer } from './server';
+
+export const RAMP_USAGE = `perf-harness run ramp — V2 limits-discovery executor (fresh server per step)
+
+Required:
+  --plan <file>               ramp plan JSON ({ port?, defaults, steps[] })
+Common:
+  --port <n>                  server port (overrides plan.port; default plan.port || 3345)
+  --out <file>                results JSONL (default <out-dir>/<label>-results.jsonl)
+  --label <name>              results-file label (default: plan basename)
+  --only step1,step2          run only the named steps
+  --out-dir <dir>             artifact dir (default ./perf-out)
+  --server-cmd "<cmd>"        server launch command (default: node <repo>/packages/cli/dist/index.js)
+  --pg-* / PG*                Postgres connection overrides (default :5433 constructive)
+  --allow-hub                 permit reserved hub ports (danger)
+  --help
+
+Auth for harness steps uses PERF_PASSWORD from the environment (never argv).
+Each step's cfg = { ...plan.defaults, ...step }.`;
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+const MB = (b: number): number => Math.round((b / 1024 / 1024) * 10) / 10;
+
+// ---------------------------------------------------------------------------
+// Plan shape
+// ---------------------------------------------------------------------------
+export interface RampDefaults {
+  heapMb?: number;
+  rps?: number;
+  durationSec?: number;
+  shape?: string;
+  auth?: number;
+  mix?: string;
+  cacheMax?: number;
+  instanceHeapBytes?: number;
+  sentinelSec?: number;
+  seed?: number;
+  coldTimeoutMs?: number;
+  serverEnv?: Record<string, string>;
+  [k: string]: any;
+}
+
+export interface RampStep {
+  name: string;
+  fleet?: string;
+  coldBurst?: boolean;
+  [k: string]: any;
+}
+
+export interface RampPlan {
+  port?: number;
+  defaults: RampDefaults;
+  steps: RampStep[];
+}
+
+// The per-step config: plan defaults overlaid by the step's own fields. Exported
+// for tests. Pure — never mutates its inputs.
+export function mergeStepConfig(defaults: RampDefaults, step: RampStep): RampDefaults & RampStep {
+  return { ...defaults, ...step };
+}
+
+// ---------------------------------------------------------------------------
+// PG backend sampling (server pools + LISTEN connections)
+// ---------------------------------------------------------------------------
+interface PgBackendSampler {
+  max: number;
+  last: number;
+  samples: number;
+  stop: boolean;
+  err: string | null;
+  reconnects: number;
+}
+
+function startPgBackendSampler(pg: PgConfig): PgBackendSampler {
+  const { Client } = getPg();
+  const state: PgBackendSampler = { max: 0, last: 0, samples: 0, stop: false, err: null, reconnects: 0 };
+  void (async () => {
+    // PG may crash-recover mid-step (introspection OOM inside its cgroup) —
+    // swallow client errors and reconnect rather than killing the executor.
+    while (!state.stop) {
+      let client: any;
+      try {
+        client = new Client(pg);
+        client.on('error', () => {});
+        await client.connect();
+        while (!state.stop) {
+          const r = await client.query(
+            `SELECT count(*)::int AS c FROM pg_stat_activity
+              WHERE datname = current_database() AND pid <> pg_backend_pid()`
+          );
+          state.last = r.rows[0].c;
+          state.max = Math.max(state.max, state.last);
+          state.samples++;
+          await sleep(5000);
+        }
+      } catch (e: any) {
+        state.err = String(e && e.message ? e.message : e);
+        state.reconnects++;
+      } finally {
+        try {
+          await client?.end();
+        } catch {
+          /* recovery window */
+        }
+      }
+      if (!state.stop) await sleep(5000);
+    }
+  })();
+  return state;
+}
+
+// ---------------------------------------------------------------------------
+// Workloads
+// ---------------------------------------------------------------------------
+// Invoke the harness as a child of THIS CLI (`perf-harness load harness ...`),
+// mirroring the original's per-step process isolation. Credentials flow via the
+// inherited environment (PERF_PASSWORD) — never on argv.
+function runHarnessChild(flags: string[]): Promise<{ code: number | null; tail: string }> {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [process.argv[1], 'load', 'harness', ...flags], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    let tail = '';
+    child.stdout.on('data', (d) => {
+      process.stdout.write(d);
+      tail = (tail + d).slice(-4000);
+    });
+    child.stderr.on('data', (d) => {
+      process.stderr.write(d);
+      tail = (tail + d).slice(-4000);
+    });
+    child.on('exit', (code) => resolve({ code, tail }));
+    child.on('error', (err) => resolve({ code: 1, tail: `${tail}\n[spawn error] ${err && err.message ? err.message : err}` }));
+  });
+}
+
+interface ColdHit {
+  dbname: string;
+  status: number;
+  ms: number;
+  err?: string;
+}
+
+async function coldBurst(fleetPath: string, port: number, coldTimeoutMs: number): Promise<{ wave1: ColdHit[]; wave2: ColdHit[] }> {
+  const { tenants } = loadFleet(fleetPath);
+  const one = async (t: Tenant): Promise<ColdHit> => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), coldTimeoutMs);
+    const start = performance.now();
+    try {
+      const res = await fetch(`http://${t.apiHost}:${port}/graphql`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ query: 'query { __typename }' }),
+        signal: ac.signal
+      });
+      await res.text();
+      return { dbname: t.dbname, status: res.status, ms: Math.round(performance.now() - start) };
+    } catch (e) {
+      return { dbname: t.dbname, status: 0, ms: Math.round(performance.now() - start), err: String(e).slice(0, 120) };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  console.log(`[cold-burst] firing ${tenants.length} concurrent first-hits...`);
+  const wave1 = await Promise.all(tenants.map(one));
+  const wave2 = await Promise.all(tenants.map(one)); // warm check
+  return { wave1, wave2 };
+}
+
+// Resolve a plan's `step.fleet` (relative to cwd first, then the plan dir).
+function resolveFleetPath(planDir: string, fleet: string): string {
+  if (path.isAbsolute(fleet)) return fleet;
+  const relCwd = path.resolve(process.cwd(), fleet);
+  if (fs.existsSync(relCwd)) return relCwd;
+  const relPlan = path.resolve(planDir, fleet);
+  if (fs.existsSync(relPlan)) return relPlan;
+  return relCwd; // loadFleet will throw a clear ENOENT
+}
+
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+export async function runRamp(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) {
+    console.log(RAMP_USAGE);
+    return 0;
+  }
+  const planArg = typeof argv.plan === 'string' ? argv.plan : '';
+  const planPath = planArg ? path.resolve(process.cwd(), planArg) : '';
+  if (!planPath || !fs.existsSync(planPath)) {
+    console.error('run ramp: --plan <file> is required');
+    return 1;
+  }
+  const plan: RampPlan = JSON.parse(fs.readFileSync(planPath, 'utf8'));
+  const planDir = path.dirname(planPath);
+
+  const allowHub = asBool(argv['allow-hub']);
+  const port = asInt(argv.port, plan.port || 3345);
+  assertPortAllowed(port, allowHub, 'server-port');
+
+  const pg = pgConfigFromArgv(argv);
+  const outDir = resolveOutDir(argv);
+  const repoRoot = findRepoRoot();
+  const serverCmd = resolveServerCmd(argv, repoRoot);
+
+  const label = typeof argv.label === 'string' && argv.label ? argv.label : path.basename(planPath).replace(/\.json$/i, '');
+  const outFile = typeof argv.out === 'string' && argv.out ? path.resolve(process.cwd(), argv.out) : path.join(outDir, `${label}-results.jsonl`);
+
+  const only = (typeof argv.only === 'string' ? argv.only : '').split(',').filter(Boolean);
+  const steps = (plan.steps || []).filter((s) => only.length === 0 || only.includes(s.name));
+
+  console.log(`[ramp] plan=${path.basename(planPath)} steps=${steps.map((s) => s.name).join(',')} port=${port} -> ${outFile}`);
+
+  for (const step of steps) {
+    const cfg = mergeStepConfig(plan.defaults || {}, step);
+    const name = `${step.name}-h${cfg.heapMb}`;
+    const metricsFile = path.join(outDir, `metrics-${name}.jsonl`);
+    const harnessOut = path.join(outDir, `harness-${name}.json`);
+    if (fs.existsSync(metricsFile)) fs.rmSync(metricsFile);
+
+    console.log(
+      `\n===== STEP ${name}: heap=${cfg.heapMb}MB fleet=${step.fleet} ` +
+        `${step.coldBurst ? 'COLD-BURST' : `rps=${cfg.rps} dur=${cfg.durationSec}s shape=${cfg.shape}`} =====`
+    );
+
+    const record: any = {
+      name: step.name,
+      heapMb: cfg.heapMb,
+      fleet: step.fleet,
+      config: cfg,
+      startedAt: new Date().toISOString()
+    };
+    const pgSampler = startPgBackendSampler(pg);
+    const t0 = Date.now();
+    let server: SpawnedServer | null = null;
+    try {
+      server = await spawnServer({
+        name: `server-${name}`,
+        port,
+        heapMb: cfg.heapMb,
+        metricsFile,
+        pg,
+        repoRoot,
+        outDir,
+        serverCmd,
+        cacheMax: cfg.cacheMax,
+        instanceHeapBytes: cfg.instanceHeapBytes,
+        extraEnv: cfg.serverEnv,
+        detached: false,
+        allowHub
+      });
+
+      // metrics baseline so the sampler is known-alive before load
+      const bDeadline = Date.now() + 60000;
+      while (readJsonl(metricsFile).length < 1 && Date.now() < bDeadline) await sleep(2000);
+
+      if (step.coldBurst) {
+        const fleetPath = resolveFleetPath(planDir, step.fleet);
+        record.coldBurst = await coldBurst(fleetPath, port, cfg.coldTimeoutMs ?? 420000);
+        const w1: ColdHit[] = record.coldBurst.wave1;
+        record.summary = {
+          coldOk: w1.filter((r) => r.status === 200).length,
+          cold503: w1.filter((r) => r.status === 503).length,
+          coldErr: w1.filter((r) => r.status !== 200 && r.status !== 503).length,
+          coldMsMax: Math.max(...w1.map((r) => r.ms)),
+          warmMsMax: Math.max(...record.coldBurst.wave2.map((r: ColdHit) => r.ms))
+        };
+        await sleep(15000); // let the sampler catch the post-burst state
+      } else {
+        const fleetPath = resolveFleetPath(planDir, step.fleet);
+        const flags = [
+          '--fleet', fleetPath,
+          '--port', String(port),
+          '--duration-sec', String(cfg.durationSec),
+          '--rps', String(cfg.rps),
+          '--mix', String(cfg.mix),
+          '--shape', String(cfg.shape),
+          '--auth', String(cfg.auth),
+          '--sentinel-interval-sec', String(cfg.sentinelSec ?? 60),
+          '--seed', String(cfg.seed ?? 42),
+          '--out', harnessOut
+        ];
+        const h = await runHarnessChild(flags);
+        record.harnessExit = h.code; // 2 = bleed sentinel violation
+        if (fs.existsSync(harnessOut)) {
+          const rep = JSON.parse(fs.readFileSync(harnessOut, 'utf8'));
+          record.summary = {
+            achievedRps: rep.totals?.achievedRps,
+            completed: rep.totals?.completed,
+            errRate: rep.totals?.errRate,
+            latency: rep.latencyOverall,
+            readLatency: rep.byClass?.read?.latency,
+            http: rep.http,
+            netErrors: rep.netErrors,
+            sentinelOk: rep.sentinel?.ok,
+            verdict: rep.verdict
+          };
+        } else {
+          record.error = `harness produced no report (exit ${h.code})`;
+          record.harnessTail = h.tail;
+        }
+      }
+    } catch (e: any) {
+      if (e && e.server) server = e.server as SpawnedServer; // startup crash — recover the handle
+      record.error = record.error || String(e && e.message ? e.message : e);
+    } finally {
+      pgSampler.stop = true;
+      const crashed = server ? server.exited() : true;
+      const m = readJsonl(metricsFile);
+      if (m.length) {
+        const last = m[m.length - 1];
+        record.metrics = {
+          samples: m.length,
+          rssMaxMB: MB(Math.max(...m.map((x) => x.rss))),
+          heapUsedMaxMB: MB(Math.max(...m.map((x) => x.heapUsed))),
+          heapUsedLastMB: MB(last.heapUsed),
+          buildQueueDepthMax: Math.max(...m.map((x) => x.counters?.buildQueueDepth ?? 0)),
+          lastCache: last.cache,
+          lastCounters: last.counters
+        };
+      }
+      if (server) await server.stop();
+      if (crashed) {
+        const info = server ? server.exitInfo() : { code: null, signal: null };
+        record.serverCrashed = true;
+        record.serverExit = { code: info.code, signal: info.signal };
+        record.serverLogTail = server ? server.logTail(2500) : '';
+        console.error(`[ramp] SERVER CRASHED during ${name}: code=${info.code} signal=${info.signal}`);
+      }
+      record.pgBackends = { max: pgSampler.max, samples: pgSampler.samples, err: pgSampler.err };
+      record.wallSec = Math.round((Date.now() - t0) / 1000);
+      record.endedAt = new Date().toISOString();
+      ensureParentDir(outFile);
+      fs.appendFileSync(outFile, JSON.stringify(record) + '\n');
+      console.log(`[ramp] step ${name} done in ${record.wallSec}s -> ${outFile}`);
+    }
+  }
+  console.log(`\n[ramp] all steps complete -> ${outFile}`);
+  return 0;
+}
diff --git a/packages/perf-harness/src/run/server.ts b/packages/perf-harness/src/run/server.ts
new file mode 100644
index 0000000000..03c0ce9d49
--- /dev/null
+++ b/packages/perf-harness/src/run/server.ts
@@ -0,0 +1,200 @@
+/**
+ * Server child management — shared by `run ramp`, `run soak`, and
+ * `measure instance-heap`.
+ *
+ * Boots the built cnc server with the validated soak recipe env (heap cap,
+ * blueprint pooling, metrics JSONL + optional /metrics endpoint, optional
+ * instance-heap estimate) and the fixed server flags, then waits for the port
+ * to accept a loopback connection before resolving.
+ *
+ * Two modes:
+ *   - managed (default): the child stays a direct child of this process. The
+ *     returned handle exposes live crash introspection (exited/exitInfo/logTail)
+ *     and a `stop()` that does SIGTERM -> 15s -> SIGKILL. This is what `run ramp`
+ *     uses so an 896MB-heap OOM mid-step is a recorded FINDING, not an abort.
+ *   - detached (`detached: true`): the child outlives this CLI (core/proc
+ *     spawnDetached — own process group, log file, pid file). This is what
+ *     `run soak start` uses.
+ *
+ * Return shape is a structural superset of the DESIGN `{ pid, stop }` contract.
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { assertPortAllowed, PgConfig } from '../core/config';
+import { isAlive, spawnDetached, stopPid, waitForPort } from '../core/proc';
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+export interface ServerSpawnOpts {
+  name: string;
+  port: number;
+  heapMb: number;
+  metricsFile: string;
+  pg: PgConfig;
+  repoRoot: string;
+  outDir: string;
+  serverCmd?: string[];
+  cacheMax?: number;
+  instanceHeapBytes?: number;
+  metricsEndpoint?: boolean;
+  extraEnv?: Record<string, string>;
+  detached?: boolean;
+  allowHub?: boolean;
+}
+
+export interface SpawnedServer {
+  pid: number;
+  stop: () => Promise<void>;
+  // Live crash introspection (used by ramp's crash-tolerated-and-recorded path).
+  exited: () => boolean;
+  exitInfo: () => { code: number | null; signal: string | null };
+  logTail: (maxChars?: number) => string;
+  // Set only in detached mode.
+  logPath: string | null;
+  pidPath: string | null;
+}
+
+// Build the child env from the validated soak recipe. extraEnv is applied
+// BEFORE PG* (matching v2-ramps startServer ordering) so PgConfig is always the
+// single source of truth for the DB connection — extraEnv can tune GRAPHILE_*
+// but must never redirect the server to a different database.
+function buildServerEnv(o: ServerSpawnOpts): Record<string, string> {
+  const env: Record<string, string> = {
+    NODE_ENV: 'production',
+    NODE_OPTIONS: `--max-old-space-size=${o.heapMb}`,
+    GRAPHILE_DEBUG_METRICS: '1',
+    GRAPHILE_DEBUG_METRICS_FILE: o.metricsFile,
+    GRAPHILE_BLUEPRINT_POOLING: '1'
+  };
+  if (o.metricsEndpoint) env.GRAPHILE_METRICS_ENDPOINT = '1';
+  if (o.cacheMax) env.GRAPHILE_CACHE_MAX = String(o.cacheMax);
+  if (o.instanceHeapBytes) env.GRAPHILE_CACHE_INSTANCE_HEAP_BYTES = String(o.instanceHeapBytes);
+  if (o.extraEnv) Object.assign(env, o.extraEnv);
+  env.PGHOST = o.pg.host;
+  env.PGPORT = String(o.pg.port);
+  env.PGUSER = o.pg.user;
+  env.PGPASSWORD = o.pg.password;
+  env.PGDATABASE = o.pg.database;
+  return env;
+}
+
+function resolveServerArgv(o: ServerSpawnOpts): { cmd: string; args: string[] } {
+  const serverCmd = o.serverCmd && o.serverCmd.length
+    ? o.serverCmd
+    : ['node', path.join(o.repoRoot, 'packages', 'cli', 'dist', 'index.js')];
+  const cmd = serverCmd[0];
+  const baseArgs = serverCmd.slice(1);
+  const serverArgs = ['server', '--port', String(o.port), '--origin', '*', '--simpleInflection', '--postgis', '--servicesApi'];
+  return { cmd, args: [...baseArgs, ...serverArgs] };
+}
+
+export async function spawnServer(o: ServerSpawnOpts): Promise<SpawnedServer> {
+  // Guardrail: refuse to bind a reserved hub port unless explicitly allowed.
+  assertPortAllowed(o.port, !!o.allowHub, 'server-port');
+
+  const { cmd, args } = resolveServerArgv(o);
+  const overrides = buildServerEnv(o);
+
+  if (o.detached) {
+    const { pid, logPath, pidPath } = spawnDetached({
+      name: o.name,
+      cmd,
+      args,
+      env: overrides,
+      cwd: o.repoRoot,
+      outDir: o.outDir
+    });
+    const handle: SpawnedServer = {
+      pid,
+      stop: async (): Promise<void> => {
+        await stopPid(pid, 15000);
+      },
+      exited: () => !isAlive(pid),
+      exitInfo: () => ({ code: null, signal: null }),
+      logTail: (maxChars = 8000) => {
+        try {
+          return fs.readFileSync(logPath, 'utf8').slice(-maxChars);
+        } catch {
+          return '';
+        }
+      },
+      logPath,
+      pidPath
+    };
+    try {
+      await waitForPort(o.port, 120000);
+    } catch (err: any) {
+      // Hand the started child back so the caller can record/stop it.
+      if (err) err.server = handle;
+      throw err;
+    }
+    return handle;
+  }
+
+  // Managed mode: keep the child handle so the caller can observe a crash.
+  const state: { log: string; exited: boolean; exitCode: number | null; exitSignal: string | null } = {
+    log: '',
+    exited: false,
+    exitCode: null,
+    exitSignal: null
+  };
+  const child = spawn(cmd, args, {
+    cwd: o.repoRoot,
+    env: { ...process.env, ...overrides },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  const append = (d: any): void => {
+    state.log = (state.log + d).slice(-8000);
+  };
+  if (child.stdout) child.stdout.on('data', append);
+  if (child.stderr) child.stderr.on('data', append);
+  child.on('exit', (code, signal) => {
+    state.exited = true;
+    state.exitCode = code;
+    state.exitSignal = signal;
+  });
+  child.on('error', (err) => {
+    state.exited = true;
+    state.exitCode = state.exitCode == null ? 1 : state.exitCode;
+    append(`\n[spawn error] ${err && err.message ? err.message : err}`);
+  });
+
+  const stop = async (): Promise<void> => {
+    if (state.exited) return;
+    try {
+      child.kill('SIGTERM');
+    } catch {
+      return;
+    }
+    const deadline = Date.now() + 15000;
+    while (!state.exited && Date.now() < deadline) await sleep(300);
+    if (!state.exited) {
+      try {
+        child.kill('SIGKILL');
+      } catch {
+        return;
+      }
+      const killDeadline = Date.now() + 2000;
+      while (!state.exited && Date.now() < killDeadline) await sleep(100);
+    }
+  };
+
+  const handle: SpawnedServer = {
+    pid: child.pid as number,
+    stop,
+    exited: () => state.exited,
+    exitInfo: () => ({ code: state.exitCode, signal: state.exitSignal }),
+    logTail: (maxChars = 8000) => state.log.slice(-maxChars),
+    logPath: null,
+    pidPath: null
+  };
+  try {
+    await waitForPort(o.port, 120000);
+  } catch (err: any) {
+    if (err) err.server = handle;
+    throw err;
+  }
+  return handle;
+}
diff --git a/packages/perf-harness/src/run/soak.ts b/packages/perf-harness/src/run/soak.ts
new file mode 100644
index 0000000000..47eccd2758
--- /dev/null
+++ b/packages/perf-harness/src/run/soak.ts
@@ -0,0 +1,363 @@
+/**
+ * `run soak start|status|stop` — the soak orchestrator.
+ *
+ * NEW in the package port: replaces the hand-written out/run-soak-*.sh scripts.
+ * A soak is six long-lived components launched detached (own process group, log
+ * file, pid file) under --out-dir, tagged by --label:
+ *
+ *   server      cnc server: heap 3584, blueprint pooling, instance-heap
+ *               estimate, /metrics endpoint, metrics JSONL
+ *   harness     `load harness`  rps 30, zipf, authenticated, canary sentinel 60s
+ *   churn       `load churn`    schema:update NOTIFY every 3600s
+ *   soak-ops    `run soak-ops`  provision/drop cycle every 7200s
+ *   collector   `measure collector`  RSS + metrics tail on the server pid
+ *   pg-sampler  `measure pg`    docker + pg_stat_activity every 30s
+ *
+ * Recipe distilled from run-soak-server.sh / run-soak-load.sh / run-pg-sampler.sh.
+ * Credentials reach the harness child via the PERF_PASSWORD env var, never argv.
+ *
+ *   start   boots the server (waits for the port), then the load stack; prints a
+ *           JSON summary of pids + artifact paths.
+ *   status  pid liveness + last harness progress line + a /metrics snapshot
+ *           (loopback only, if the port answers).
+ *   stop    SIGTERM fan-out IN ORDER harness -> collector -> churn -> soak-ops ->
+ *           pg-sampler -> server (each waited on), then writes <label>.done.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Argv, asBool, asInt, usageExit } from '../core/args';
+import { assertPortAllowed, findRepoRoot, pgConfigFromArgv, resolveCreds, resolveOutDir, resolveServerCmd } from '../core/config';
+import { isAlive, readJsonl, readPid, spawnDetached, stopPid, writeDone } from '../core/proc';
+import { spawnServer, SpawnedServer } from './server';
+
+export const SOAK_USAGE = `perf-harness run soak <start|status|stop> — long-running soak orchestrator
+
+Common:
+  --label <name>              soak label / file prefix (default soak)
+  --out-dir <dir>             artifact dir (default ./perf-out)
+
+start:
+  --fleet <file>              fleet manifest (required)
+  --duration-sec <n>          soak length (default 86400)
+  --heap-mb <n>               server heap cap MB (default 3584)
+  --port <n>                  server port (default 3333)
+  --instance-heap-bytes <n>   GRAPHILE_CACHE_INSTANCE_HEAP_BYTES (default 1450000000)
+  --rps <n>                   harness target rps (default 30)
+  --container <name>          docker container for pg-sampler (default constructive-scale-pg)
+  --server-cmd "<cmd>"        server launch command
+  --pg-* / PG*                Postgres connection overrides (default :5433 constructive)
+  --email <addr>              seeder email (default seeder@gmail.com)
+  --password <pw>             seeder password (or PERF_PASSWORD env; required for auth)
+  --allow-hub                 permit reserved hub ports (danger)
+
+status | stop:
+  (uses --label / --out-dir to locate the running soak)`;
+
+// Component keys. Pid/log files are <label>-<key>.{pid,log} under --out-dir.
+const COMPONENTS = ['server', 'harness', 'churn', 'soak-ops', 'collector', 'pg-sampler'] as const;
+type ComponentKey = (typeof COMPONENTS)[number];
+
+// SIGTERM fan-out order: load components flush FIRST, the server dies LAST.
+export const SOAK_STOP_ORDER: ComponentKey[] = ['harness', 'collector', 'churn', 'soak-ops', 'pg-sampler', 'server'];
+
+// Per-component SIGTERM grace before SIGKILL. soak-ops gets a generous window so
+// an in-flight cycle child + the final drop can finish cleanly.
+const STOP_TERM_TIMEOUT_MS: Record<ComponentKey, number> = {
+  harness: 30000,
+  collector: 15000,
+  churn: 15000,
+  'soak-ops': 1200000,
+  'pg-sampler': 15000,
+  server: 30000
+};
+
+const err = (...a: any[]): void => {
+  process.stderr.write(`${a.join(' ')}\n`);
+};
+const out = (obj: any): void => {
+  process.stdout.write(`${JSON.stringify(obj)}\n`);
+};
+const compName = (label: string, key: ComponentKey): string => `${label}-${key}`;
+
+// ---------------------------------------------------------------------------
+export async function runSoak(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) {
+    console.log(SOAK_USAGE);
+    return 0;
+  }
+  // Locate the action among the command-path positionals. Scanning (rather than
+  // indexing a fixed slot) keeps this correct whether the top-level router
+  // passes the full argv (`_ = ['run','soak','start']`) or a stripped one.
+  const action = argv._.find((p) => p === 'start' || p === 'status' || p === 'stop');
+  if (action === 'start') return soakStart(argv);
+  if (action === 'status') return soakStatus(argv);
+  if (action === 'stop') return soakStop(argv);
+  return usageExit(SOAK_USAGE);
+}
+
+// ---------------------------------------------------------------------------
+// start
+// ---------------------------------------------------------------------------
+async function soakStart(argv: Argv): Promise<number> {
+  const allowHub = asBool(argv['allow-hub']);
+  const pg = pgConfigFromArgv(argv);
+  const outDir = resolveOutDir(argv);
+  const repoRoot = findRepoRoot();
+  const serverCmd = resolveServerCmd(argv, repoRoot);
+
+  const label = typeof argv.label === 'string' && argv.label ? argv.label : 'soak';
+  const port = asInt(argv.port, 3333);
+  assertPortAllowed(port, allowHub, 'server-port');
+  const heapMb = asInt(argv['heap-mb'], 3584);
+  const durationSec = asInt(argv['duration-sec'], 86400);
+  const instanceHeapBytes = asInt(argv['instance-heap-bytes'], 1450000000);
+  const rps = asInt(argv.rps, 30);
+  const container = typeof argv.container === 'string' && argv.container ? argv.container : 'constructive-scale-pg';
+
+  const fleetArg = typeof argv.fleet === 'string' ? argv.fleet : '';
+  const fleetPath = fleetArg ? path.resolve(process.cwd(), fleetArg) : '';
+  if (!fleetPath || !fs.existsSync(fleetPath)) {
+    err('run soak start: --fleet <file> is required (harness + churn drive it)');
+    return 1;
+  }
+
+  const creds = resolveCreds(argv);
+  if (!creds.password) {
+    err('run soak start: no password — set --password or PERF_PASSWORD (the soak harness authenticates)');
+    return 1;
+  }
+
+  // Refuse to stack a second soak on top of a live one.
+  const existing = readPid(outDir, compName(label, 'server'));
+  if (existing && isAlive(existing)) {
+    err(`run soak start: a soak labelled "${label}" is already running (server pid ${existing}). Stop it first or pick a new --label.`);
+    return 1;
+  }
+
+  const metricsFile = path.join(outDir, `metrics-${label}.jsonl`);
+  const harnessOut = path.join(outDir, `harness-${label}.json`);
+  const collectorOut = path.join(outDir, `collector-${label}.json`);
+  const pgFile = path.join(outDir, `pg-${label}.jsonl`);
+
+  const pgEnv: Record<string, string> = {
+    PGHOST: pg.host,
+    PGPORT: String(pg.port),
+    PGUSER: pg.user,
+    PGPASSWORD: pg.password,
+    PGDATABASE: pg.database
+  };
+
+  // 1) server (detached; waits for the port before returning).
+  err(`[soak] ${new Date().toISOString()} starting server on :${port} (heap=${heapMb}MB instanceHeap=${instanceHeapBytes})`);
+  let server: SpawnedServer;
+  try {
+    server = await spawnServer({
+      name: compName(label, 'server'),
+      port,
+      heapMb,
+      metricsFile,
+      pg,
+      repoRoot,
+      outDir,
+      serverCmd,
+      instanceHeapBytes,
+      metricsEndpoint: true,
+      detached: true,
+      allowHub
+    });
+  } catch (e: any) {
+    if (e && e.server) {
+      try {
+        await e.server.stop();
+      } catch {
+        /* best effort */
+      }
+    }
+    err(`[soak] server never came up: ${e && e.message ? e.message : e}`);
+    writeDone(outDir, label, `server-never-came-up ${new Date().toISOString()}`);
+    return 1;
+  }
+  err(`[soak] server up (pid ${server.pid}); starting load stack`);
+
+  const self = process.argv[1];
+  const pids: Record<ComponentKey, number> = { server: server.pid } as any;
+
+  // 2) harness — creds via env PERF_PASSWORD, never argv.
+  pids.harness = spawnDetached({
+    name: compName(label, 'harness'),
+    cmd: process.execPath,
+    args: [
+      self, 'load', 'harness',
+      '--fleet', fleetPath,
+      '--port', String(port),
+      '--duration-sec', String(durationSec),
+      '--rps', String(rps),
+      '--mix', 'read:0.7,write:0.25,meta:0.05',
+      '--shape', 'zipf',
+      '--auth', '1',
+      '--sentinel-interval-sec', '60',
+      '--email', creds.email,
+      '--out', harnessOut
+    ],
+    env: { PERF_PASSWORD: creds.password },
+    cwd: repoRoot,
+    outDir
+  }).pid;
+
+  // 3) churn — NOTE: run-soak-load.sh omitted --fleet, which churn-driver
+  // requires and would reject; the orchestrator passes it.
+  pids.churn = spawnDetached({
+    name: compName(label, 'churn'),
+    cmd: process.execPath,
+    args: [
+      self, 'load', 'churn',
+      '--fleet', fleetPath,
+      '--interval-notify-sec', '3600',
+      '--provision-every-sec', '0',
+      '--duration-sec', String(durationSec)
+    ],
+    env: pgEnv,
+    cwd: repoRoot,
+    outDir
+  }).pid;
+
+  // 4) soak-ops — provision/drop cycles (PG via env, creds via PERF_PASSWORD).
+  pids['soak-ops'] = spawnDetached({
+    name: compName(label, 'soak-ops'),
+    cmd: process.execPath,
+    args: [self, 'run', 'soak-ops', '--interval-sec', '7200', '--duration-sec', String(durationSec)],
+    env: { ...pgEnv, PERF_PASSWORD: creds.password },
+    cwd: repoRoot,
+    outDir
+  }).pid;
+
+  // 5) collector — RSS + metrics tail on the server pid (runs until pid exits).
+  pids.collector = spawnDetached({
+    name: compName(label, 'collector'),
+    cmd: process.execPath,
+    args: [self, 'measure', 'collector', '--pid', String(server.pid), '--metrics-file', metricsFile, '--out', collectorOut],
+    cwd: repoRoot,
+    outDir
+  }).pid;
+
+  // 6) pg-sampler — docker + pg_stat_activity every 30s for the full soak.
+  pids['pg-sampler'] = spawnDetached({
+    name: compName(label, 'pg-sampler'),
+    cmd: process.execPath,
+    args: [
+      self, 'measure', 'pg',
+      '--out', pgFile,
+      '--interval-sec', '30',
+      '--duration-sec', String(durationSec),
+      '--container', container
+    ],
+    env: pgEnv,
+    cwd: repoRoot,
+    outDir
+  }).pid;
+
+  err(`[soak] started: ${COMPONENTS.map((k) => `${k}=${pids[k]}`).join(' ')}`);
+  out({
+    t: 'soak-start',
+    label,
+    port,
+    durationSec,
+    heapMb,
+    instanceHeapBytes,
+    pids,
+    artifacts: {
+      outDir,
+      metricsFile,
+      harnessOut,
+      collectorOut,
+      pgFile,
+      logs: Object.fromEntries(COMPONENTS.map((k) => [k, path.join(outDir, `${compName(label, k)}.log`)]))
+    }
+  });
+  return 0;
+}
+
+// ---------------------------------------------------------------------------
+// status
+// ---------------------------------------------------------------------------
+async function soakStatus(argv: Argv): Promise<number> {
+  const allowHub = asBool(argv['allow-hub']);
+  const outDir = resolveOutDir(argv);
+  const label = typeof argv.label === 'string' && argv.label ? argv.label : 'soak';
+  const port = asInt(argv.port, 3333);
+  assertPortAllowed(port, allowHub, 'server-port');
+
+  const components = COMPONENTS.map((key) => {
+    const pid = readPid(outDir, compName(label, key));
+    return { name: key, pid, alive: pid ? isAlive(pid) : false };
+  });
+  const serverAlive = components.find((c) => c.name === 'server')?.alive === true;
+
+  // Last harness progress line from its log (JSON lines; stderr noise skipped).
+  const harnessLog = path.join(outDir, `${compName(label, 'harness')}.log`);
+  const lines = readJsonl(harnessLog);
+  const progress = lines.filter((l) => l && l.t === 'progress');
+  const lastHarnessProgress = progress.length ? progress[progress.length - 1] : lines.length ? lines[lines.length - 1] : null;
+
+  // /metrics snapshot — loopback only, only if the server pid is alive.
+  const metrics = serverAlive ? await fetchMetrics(port) : null;
+
+  out({
+    t: 'soak-status',
+    label,
+    running: components.some((c) => c.alive),
+    components,
+    lastHarnessProgress,
+    metrics
+  });
+  return 0;
+}
+
+async function fetchMetrics(port: number): Promise<any> {
+  for (const host of ['127.0.0.1', '[::1]']) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 2000);
+    try {
+      const res = await fetch(`http://${host}:${port}/metrics`, { signal: ac.signal });
+      const text = await res.text();
+      try {
+        return { host, status: res.status, json: JSON.parse(text) };
+      } catch {
+        return { host, status: res.status, text: text.slice(0, 4000) };
+      }
+    } catch {
+      /* try the next loopback family */
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// stop
+// ---------------------------------------------------------------------------
+async function soakStop(argv: Argv): Promise<number> {
+  const outDir = resolveOutDir(argv);
+  const label = typeof argv.label === 'string' && argv.label ? argv.label : 'soak';
+
+  const results: Array<{ name: ComponentKey; pid: number | null; result: string }> = [];
+  for (const key of SOAK_STOP_ORDER) {
+    const pid = readPid(outDir, compName(label, key));
+    if (!pid || !isAlive(pid)) {
+      results.push({ name: key, pid, result: pid ? 'gone' : 'absent' });
+      err(`[soak] stop ${key}: ${pid ? 'already gone' : 'no pid file'}`);
+      continue;
+    }
+    err(`[soak] stopping ${key} (pid ${pid})...`);
+    const result = await stopPid(pid, STOP_TERM_TIMEOUT_MS[key]);
+    results.push({ name: key, pid, result });
+    err(`[soak] ${key} -> ${result}`);
+  }
+
+  const doneBody = `stopped ${new Date().toISOString()} :: ${results.map((r) => `${r.name}=${r.result}`).join(' ')}`;
+  writeDone(outDir, label, doneBody);
+  out({ t: 'soak-stop', label, order: SOAK_STOP_ORDER, results, done: path.join(outDir, `${label}.done`) });
+  return 0;
+}
diff --git a/packages/perf-harness/src/run/soakOps.ts b/packages/perf-harness/src/run/soakOps.ts
new file mode 100644
index 0000000000..afce207bb0
--- /dev/null
+++ b/packages/perf-harness/src/run/soakOps.ts
@@ -0,0 +1,149 @@
+/**
+ * `run soak-ops` — V3 soak operations churn (port of soak-ops.mjs).
+ *
+ * Every --interval-sec: provision ONE new tenant (`fleet provision`, own
+ * prefix), then drop the tenant created by the PREVIOUS cycle (`fleet
+ * teardown`). Net effect: the soak continuously exercises the full provision +
+ * teardown paths (catalog writes, schema:update NOTIFY -> flush -> rebuild on
+ * next hit) WITHOUT net catalog growth — important because instance heap scales
+ * ~21KB/pg_class row, so unbounded provisioning would inflate the resident
+ * instance past the heap mid-soak and turn a longevity test into a slow OOM.
+ *
+ * Both provision and teardown are child invocations of THIS CLI. The created
+ * tenant name is recovered from the provision child's stdout.
+ *
+ * FIX vs the original: a SIGINT/SIGTERM now stops AFTER the in-flight cycle's
+ * child processes exit, performs the final drop, and exits cleanly — the
+ * original had no signal handler, so a stop mid-soak could leak the last tenant.
+ */
+import { spawnSync } from 'node:child_process';
+
+import { Argv, asBool, asInt } from '../core/args';
+import { pgConfigFromArgv } from '../core/config';
+
+export const SOAK_OPS_USAGE = `perf-harness run soak-ops — cycle tenant provision/teardown during a soak
+
+Options:
+  --interval-sec <n>          cycle period (default 7200)
+  --duration-sec <n>          total run length (default 86400)
+  --prefix <name>             provision prefix (default soak)
+  --blueprint <name>          blueprint to provision (default marketplace)
+  --pg-* / PG*                Postgres connection overrides (default :5433 constructive)
+  --allow-hub                 permit reserved hub ports (danger)
+  --help
+
+Provision/teardown run as child invocations of this CLI; credentials flow via
+the inherited environment (PERF_PASSWORD), PG connection via injected PG* env.`;
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+const now = (): string => new Date().toISOString();
+
+// ---------------------------------------------------------------------------
+// Pure helpers (exported for tests)
+// ---------------------------------------------------------------------------
+export interface CycleTiming {
+  waitMs: number;
+  stop: boolean;
+}
+
+// Cycle-pacing math ported verbatim from soak-ops.mjs:
+//   wait = max(0, interval - elapsed); stop if now + wait would cross deadline.
+export function computeCycleTiming(opts: { intervalSec: number; elapsedMs: number; now: number; deadline: number }): CycleTiming {
+  const waitMs = Math.max(0, opts.intervalSec * 1000 - opts.elapsedMs);
+  const stop = opts.now + waitMs >= opts.deadline;
+  return { waitMs, stop };
+}
+
+// tenant-factory / `fleet provision` auto-picks the next free index; recover the
+// name it made from its stdout ("[<name>] OK db=" or "indices=<n>..").
+export function recoverCreatedName(out: string, prefix: string): string | null {
+  const m = /\[(\w+)\] OK db=/.exec(out) || /indices=(\d+)\.\./.exec(out);
+  if (!m) return null;
+  return m[1].startsWith(prefix) ? m[1] : `${prefix}${m[1]}`;
+}
+
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+export async function runSoakOps(argv: Argv): Promise<number> {
+  if (asBool(argv.help)) {
+    console.log(SOAK_OPS_USAGE);
+    return 0;
+  }
+  const intervalSec = asInt(argv['interval-sec'], 7200);
+  const durationSec = asInt(argv['duration-sec'], 86400);
+  const prefix = typeof argv.prefix === 'string' ? argv.prefix : 'soak';
+  const blueprint = typeof argv.blueprint === 'string' ? argv.blueprint : 'marketplace';
+
+  // Resolve PG once (this also runs the hub-port guardrail) and inject it into
+  // the child env so provision/teardown hit the same DB without creds on argv.
+  const pg = pgConfigFromArgv(argv);
+  const childEnv: Record<string, string> = {
+    ...process.env,
+    PGHOST: pg.host,
+    PGPORT: String(pg.port),
+    PGUSER: pg.user,
+    PGPASSWORD: pg.password,
+    PGDATABASE: pg.database
+  };
+
+  const runCli = (args: string[]): { status: number | null; out: string; tail: string } => {
+    const res = spawnSync(process.execPath, [process.argv[1], ...args], {
+      env: childEnv,
+      encoding: 'utf8',
+      timeout: 30 * 60 * 1000
+    });
+    const out = `${res.stdout || ''}${res.stderr || ''}`;
+    return { status: res.status, out, tail: out.split('\n').filter(Boolean).slice(-3).join(' | ') };
+  };
+
+  const deadline = Date.now() + durationSec * 1000;
+  let cycle = 0;
+  let previousName: string | null = null;
+  let stopping = false;
+  let stopReason: string | null = null;
+  const onSig = (sig: string): void => {
+    stopping = true;
+    stopReason = stopReason || sig;
+  };
+  process.on('SIGINT', () => onSig('SIGINT'));
+  process.on('SIGTERM', () => onSig('SIGTERM'));
+
+  console.log(`[soak-ops] ${now()} start: interval=${intervalSec}s duration=${durationSec}s prefix=${prefix}`);
+
+  while (!stopping && Date.now() < deadline) {
+    cycle++;
+    const t0 = Date.now();
+
+    const create = runCli(['fleet', 'provision', '--count', '1', '--prefix', prefix, '--blueprint', blueprint]);
+    const createdName = recoverCreatedName(create.out, prefix);
+    console.log(
+      `[soak-ops] ${now()} cycle=${cycle} provision status=${create.status} created=${createdName || '?'} :: ${create.tail}`
+    );
+
+    if (previousName) {
+      const drop = runCli(['fleet', 'teardown', '--only', previousName]);
+      console.log(`[soak-ops] ${now()} cycle=${cycle} drop ${previousName} status=${drop.status} :: ${drop.tail}`);
+    }
+    previousName = createdName || previousName;
+
+    // A signal that landed during the (synchronous) child runs is delivered
+    // now — stop before starting the next cycle's provision.
+    if (stopping) break;
+
+    const timing = computeCycleTiming({ intervalSec, elapsedMs: Date.now() - t0, now: Date.now(), deadline });
+    if (timing.stop) break;
+    // Interruptible wait so a signal during the long idle breaks promptly.
+    const until = Date.now() + timing.waitMs;
+    while (!stopping && Date.now() < until) await sleep(500);
+  }
+
+  // Final cleanup: drop the last soak tenant so the fleet is back to baseline.
+  // This runs on normal completion AND on signal (the fix).
+  if (previousName) {
+    const drop = runCli(['fleet', 'teardown', '--only', previousName]);
+    console.log(`[soak-ops] ${now()} final cleanup ${previousName} status=${drop.status} :: ${drop.tail}`);
+  }
+  console.log(`[soak-ops] ${now()} done after ${cycle} cycles${stopReason ? ` (${stopReason})` : ''}`);
+  return 0;
+}
diff --git a/packages/perf-harness/tsconfig.esm.json b/packages/perf-harness/tsconfig.esm.json
new file mode 100644
index 0000000000..800d7506d3
--- /dev/null
+++ b/packages/perf-harness/tsconfig.esm.json
@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "module": "es2022",
+    "rootDir": "src/",
+    "declaration": false
+  }
+}
diff --git a/packages/perf-harness/tsconfig.json b/packages/perf-harness/tsconfig.json
new file mode 100644
index 0000000000..1a9d5696cb
--- /dev/null
+++ b/packages/perf-harness/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src/"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules", "**/*.spec.*", "**/*.test.*"]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 77a6fdd282..ea42fc3bdf 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -12,6 +12,7 @@ overrides:
 packageExtensionsChecksum: sha256-x8B4zkJ4KLRX+yspUWxuggXWlz6zrBLSIh72pNhpPiE=
 
 importers:
+
   .:
     devDependencies:
       '@jest/test-sequencer':
@@ -1752,6 +1753,9 @@ importers:
       '@aws-sdk/client-s3':
         specifier: ^3.1052.0
         version: 3.1052.0
+      '@dataplan/pg':
+        specifier: 1.0.3
+        version: 1.0.3(@dataplan/json@1.0.0(grafast@1.0.2(graphql@16.13.0)))(grafast@1.0.2(graphql@16.13.0))(graphile-config@1.0.1)(graphql@16.13.0)(pg-sql2@5.0.1)(pg@8.21.0)
       '@types/cookie-parser':
         specifier: ^1.4.10
         version: 1.4.10(@types/express@5.0.6)
@@ -1782,6 +1786,9 @@ importers:
       nodemon:
         specifier: ^3.1.14
         version: 3.1.14
+      pg-introspection:
+        specifier: 1.0.1
+        version: 1.0.1
       ts-node:
         specifier: ^10.9.2
         version: 10.9.2(@types/node@25.9.1)(typescript@5.9.3)
@@ -2537,6 +2544,38 @@ importers:
         version: 0.3.0
     publishDirectory: dist
 
+  packages/perf-harness:
+    dependencies:
+      '@inquirerer/utils':
+        specifier: ^3.3.9
+        version: 3.3.9
+      graphile-cache:
+        specifier: workspace:^
+        version: link:../../graphile/graphile-cache/dist
+      inquirerer:
+        specifier: ^4.9.1
+        version: 4.9.1
+      pg:
+        specifier: ^8.21.0
+        version: 8.21.0
+    devDependencies:
+      '@inquirerer/test':
+        specifier: ^1.4.3
+        version: 1.4.3(jest@30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3)))
+      '@types/node':
+        specifier: ^22.19.11
+        version: 22.19.19
+      '@types/pg':
+        specifier: ^8.20.0
+        version: 8.20.0
+      makage:
+        specifier: ^0.3.0
+        version: 0.3.0
+      ts-node:
+        specifier: ^10.9.2
+        version: 10.9.2(@types/node@22.19.19)(typescript@5.9.3)
+    publishDirectory: dist
+
   packages/postmaster:
     dependencies:
       12factor-env:
@@ -3569,11 +3608,9 @@ importers:
     publishDirectory: dist
 
 packages:
+
   '@0no-co/graphql.web@1.2.0':
-    resolution:
-      {
-        integrity: sha512-/1iHy9TTr63gE1YcR5idjx8UREz1s0kFhydf3bBLCXyqjhkIc6igAzTOx3zPifCwFR87tsh/4Pa9cNts6d2otw==,
-      }
+    resolution: {integrity: sha512-/1iHy9TTr63gE1YcR5idjx8UREz1s0kFhydf3bBLCXyqjhkIc6igAzTOx3zPifCwFR87tsh/4Pa9cNts6d2otw==}
     peerDependencies:
       graphql: 16.13.0
     peerDependenciesMeta:
@@ -3581,682 +3618,406 @@ packages:
         optional: true
 
   '@asamuzakjp/css-color@3.2.0':
-    resolution:
-      {
-        integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==,
-      }
+    resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==}
 
   '@aws-crypto/crc32@5.2.0':
-    resolution:
-      {
-        integrity: sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg==,
-      }
-    engines: { node: '>=16.0.0' }
+    resolution: {integrity: sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg==}
+    engines: {node: '>=16.0.0'}
 
   '@aws-crypto/crc32c@5.2.0':
-    resolution:
-      {
-        integrity: sha512-+iWb8qaHLYKrNvGRbiYRHSdKRWhto5XlZUEBwDjYNf+ly5SVYG6zEoYIdxvf5R3zyeP16w4PLBn3rH1xc74Rag==,
-      }
+    resolution: {integrity: sha512-+iWb8qaHLYKrNvGRbiYRHSdKRWhto5XlZUEBwDjYNf+ly5SVYG6zEoYIdxvf5R3zyeP16w4PLBn3rH1xc74Rag==}
 
   '@aws-crypto/sha1-browser@5.2.0':
-    resolution:
-      {
-        integrity: sha512-OH6lveCFfcDjX4dbAvCFSYUjJZjDr/3XJ3xHtjn3Oj5b9RjojQo8npoLeA/bNwkOkrSQ0wgrHzXk4tDRxGKJeg==,
-      }
+    resolution: {integrity: sha512-OH6lveCFfcDjX4dbAvCFSYUjJZjDr/3XJ3xHtjn3Oj5b9RjojQo8npoLeA/bNwkOkrSQ0wgrHzXk4tDRxGKJeg==}
 
   '@aws-crypto/sha256-browser@5.2.0':
-    resolution:
-      {
-        integrity: sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==,
-      }
+    resolution: {integrity: sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==}
 
   '@aws-crypto/sha256-js@5.2.0':
-    resolution:
-      {
-        integrity: sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA==,
-      }
-    engines: { node: '>=16.0.0' }
+    resolution: {integrity: sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA==}
+    engines: {node: '>=16.0.0'}
 
   '@aws-crypto/supports-web-crypto@5.2.0':
-    resolution:
-      {
-        integrity: sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg==,
-      }
+    resolution: {integrity: sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg==}
 
   '@aws-crypto/util@5.2.0':
-    resolution:
-      {
-        integrity: sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==,
-      }
+    resolution: {integrity: sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==}
 
   '@aws-sdk/client-s3@3.1052.0':
-    resolution:
-      {
-        integrity: sha512-8fgQHfk1WjGUyowyqtMwq9HzZvIQQ86cqn9IZW5Qkq8kaolVjMmZez60qVYxKYvKhVRYUP5hWYPVCyraoud0AA==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-8fgQHfk1WjGUyowyqtMwq9HzZvIQQ86cqn9IZW5Qkq8kaolVjMmZez60qVYxKYvKhVRYUP5hWYPVCyraoud0AA==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/core@3.974.13':
-    resolution:
-      {
-        integrity: sha512-+Y5/4tHki0uYgyx8eun146DegRVQBpdKGK5RbV0FTKJPpaKTchvqVxrrRFK6Wk0JksO4iAZKw3eqxGEIwtO98w==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-+Y5/4tHki0uYgyx8eun146DegRVQBpdKGK5RbV0FTKJPpaKTchvqVxrrRFK6Wk0JksO4iAZKw3eqxGEIwtO98w==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/crc64-nvme@3.972.9':
-    resolution:
-      {
-        integrity: sha512-P+QGozmXn2mZZI7sDgk+aUm+RTI61MPSFB+Ir2vjEjEbEsE4e7hYtzrDvAUxZy9ko81h53e11+F/GYlvwDkaOQ==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-P+QGozmXn2mZZI7sDgk+aUm+RTI61MPSFB+Ir2vjEjEbEsE4e7hYtzrDvAUxZy9ko81h53e11+F/GYlvwDkaOQ==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-env@3.972.39':
-    resolution:
-      {
-        integrity: sha512-29wX9zpAvEt1vcj0psha+y6ygBHy2V/S72mp6e7q0KARLWXq+pwE/lR6qGkwknQvruh52lXvlqZIga8Hdxkucw==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-29wX9zpAvEt1vcj0psha+y6ygBHy2V/S72mp6e7q0KARLWXq+pwE/lR6qGkwknQvruh52lXvlqZIga8Hdxkucw==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-http@3.972.41':
-    resolution:
-      {
-        integrity: sha512-IA3CQTjtJkb6u1H4mE4936c8OPBMa9Jggtwe8U2Mqw/vvb/tZ5Ebd0mcZcX0uKWQhOyYo/+qNIwkV5Xh+FeJJA==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-IA3CQTjtJkb6u1H4mE4936c8OPBMa9Jggtwe8U2Mqw/vvb/tZ5Ebd0mcZcX0uKWQhOyYo/+qNIwkV5Xh+FeJJA==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-ini@3.972.43':
-    resolution:
-      {
-        integrity: sha512-4mzII+3mZEVXXE1xzrLQrCJL7/r62A63bA6SVzZoNL5rqCJghpf+xgGltVrIBBs0n+mOZBKrQl2tRREtvZ5l6A==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-4mzII+3mZEVXXE1xzrLQrCJL7/r62A63bA6SVzZoNL5rqCJghpf+xgGltVrIBBs0n+mOZBKrQl2tRREtvZ5l6A==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-login@3.972.43':
-    resolution:
-      {
-        integrity: sha512-HG7kQCwXtbv3oBV61Ins0oNX8KKyvrMqqRkb6ZiAfQHbMuHaiNaEb2KnpKLPkNpqImSBK82UkVE/kaY6IfWikA==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-HG7kQCwXtbv3oBV61Ins0oNX8KKyvrMqqRkb6ZiAfQHbMuHaiNaEb2KnpKLPkNpqImSBK82UkVE/kaY6IfWikA==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-node@3.972.44':
-    resolution:
-      {
-        integrity: sha512-sDaBIT0yrNNIPfvlsiTCmANm07zKju+ipWODjEXgZlsjMeIJR3LVp7RDyAOzUoAsTbDfYKDWp+i5WrFiQP6rmQ==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-sDaBIT0yrNNIPfvlsiTCmANm07zKju+ipWODjEXgZlsjMeIJR3LVp7RDyAOzUoAsTbDfYKDWp+i5WrFiQP6rmQ==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-process@3.972.39':
-    resolution:
-      {
-        integrity: sha512-2k/amBifLd75eXNwgvPw/2lKYSQ3NhvHQgkVKVjfUq13/eJ3JRtHmznuFenn74OK3sSfp4SMy1YB2w+UVXoKqA==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-2k/amBifLd75eXNwgvPw/2lKYSQ3NhvHQgkVKVjfUq13/eJ3JRtHmznuFenn74OK3sSfp4SMy1YB2w+UVXoKqA==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-sso@3.972.43':
-    resolution:
-      {
-        integrity: sha512-LPc3+Y4vhH1T4x6CMqwCM6hk5+SRf/Lwmgm8INm95wxTtIRHcMwQUVkDzWu4Iw/RSncxYM2BC01OrYbxOPZvyg==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-LPc3+Y4vhH1T4x6CMqwCM6hk5+SRf/Lwmgm8INm95wxTtIRHcMwQUVkDzWu4Iw/RSncxYM2BC01OrYbxOPZvyg==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/credential-provider-web-identity@3.972.43':
-    resolution:
-      {
-        integrity: sha512-wQtL34lUD/09VXjwAUo2T+I3aEXRDxMB3DKmTJL/Zj0Gi6sLDTrVhae1XVt01yzkquOWajI/sZW72JGDZ1ciTw==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-wQtL34lUD/09VXjwAUo2T+I3aEXRDxMB3DKmTJL/Zj0Gi6sLDTrVhae1XVt01yzkquOWajI/sZW72JGDZ1ciTw==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/lib-storage@3.1052.0':
-    resolution:
-      {
-        integrity: sha512-7agYCtfeOm3ylg95ysiXnmeGKo1rZY5EzDsD9t02hUL8+oo1wO3DuwF2c3IHdez/hB+QSOSKfmk/ZC5/3ybNHQ==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-7agYCtfeOm3ylg95ysiXnmeGKo1rZY5EzDsD9t02hUL8+oo1wO3DuwF2c3IHdez/hB+QSOSKfmk/ZC5/3ybNHQ==}
+    engines: {node: '>=20.0.0'}
     peerDependencies:
       '@aws-sdk/client-s3': ^3.1052.0
 
   '@aws-sdk/middleware-bucket-endpoint@3.972.15':
-    resolution:
-      {
-        integrity: sha512-O2HDANa+MrvbxpaRVQDiH3T13uAa9AkMjKyZmDygwauAmmvqZ5B0iRmKW+fuVGW6NPXuyXurFgIx69lSvmAWGA==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-O2HDANa+MrvbxpaRVQDiH3T13uAa9AkMjKyZmDygwauAmmvqZ5B0iRmKW+fuVGW6NPXuyXurFgIx69lSvmAWGA==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-expect-continue@3.972.13':
-    resolution:
-      {
-        integrity: sha512-sHiqIFg8o2ipT7t40B89Vj0ubSUtY6OSt/+Ee/OXhHch5K4+81zP2+QX8Lkc/nJ2QSmCySxOke7TEbmX69fe2g==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-sHiqIFg8o2ipT7t40B89Vj0ubSUtY6OSt/+Ee/OXhHch5K4+81zP2+QX8Lkc/nJ2QSmCySxOke7TEbmX69fe2g==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-flexible-checksums@3.974.21':
-    resolution:
-      {
-        integrity: sha512-alAu9heyiBK/OmRNXVxq8mmPTgeW2AQ6EYjRsI38kPZa1MZvt2Jh+BlGq7/GG9OVXOaEgD7DlGj/Lzfy5OmuEg==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-alAu9heyiBK/OmRNXVxq8mmPTgeW2AQ6EYjRsI38kPZa1MZvt2Jh+BlGq7/GG9OVXOaEgD7DlGj/Lzfy5OmuEg==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-location-constraint@3.972.11':
-    resolution:
-      {
-        integrity: sha512-hkfspNUP4criAH6ton6BGKgnm5dZx+7bUOy1YqlTfejDeUPAM23D81q/IX+hdlS3KUsfwGz5ADTqZWKBEUpf4A==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-hkfspNUP4criAH6ton6BGKgnm5dZx+7bUOy1YqlTfejDeUPAM23D81q/IX+hdlS3KUsfwGz5ADTqZWKBEUpf4A==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-sdk-s3@3.972.42':
-    resolution:
-      {
-        integrity: sha512-/xNqNGXv9LaxZd25L9VV4pnSOw9OdDNO4rAHamM+h3KQBSITljIH9vk3dveGga1I2j36lQd0rdG3gjNEXvtNew==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-/xNqNGXv9LaxZd25L9VV4pnSOw9OdDNO4rAHamM+h3KQBSITljIH9vk3dveGga1I2j36lQd0rdG3gjNEXvtNew==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-ssec@3.972.11':
-    resolution:
-      {
-        integrity: sha512-7PQvGNhtveKlvVqNahqWx5yrwxP7ecwAoB1dYBf8eKwfo2tzzCbNnW+q2nO3N066ktQaB4iBQbDRWtizm+amoQ==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-7PQvGNhtveKlvVqNahqWx5yrwxP7ecwAoB1dYBf8eKwfo2tzzCbNnW+q2nO3N066ktQaB4iBQbDRWtizm+amoQ==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/nested-clients@3.997.11':
-    resolution:
-      {
-        integrity: sha512-nWXXJ1r/r8N2Gw1pWolRgED38/A9A8DHR2ETWIv220zh4PZHcybbR4hUVWWktmNXTRHzDJwRluapHn0rZxuoqA==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-nWXXJ1r/r8N2Gw1pWolRgED38/A9A8DHR2ETWIv220zh4PZHcybbR4hUVWWktmNXTRHzDJwRluapHn0rZxuoqA==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/s3-request-presigner@3.1052.0':
-    resolution:
-      {
-        integrity: sha512-VDULO8AQlgcYZHRYn3qaBfYiM//aWxdlvQsTdcP+EQgSjki3z+mhD7rMy1RKnu4VvRK/xjJFOKwMA3cDM8eLtw==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-VDULO8AQlgcYZHRYn3qaBfYiM//aWxdlvQsTdcP+EQgSjki3z+mhD7rMy1RKnu4VvRK/xjJFOKwMA3cDM8eLtw==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/signature-v4-multi-region@3.996.28':
-    resolution:
-      {
-        integrity: sha512-qs9z5LqXO/CZC2Lg9SGKpoLU8Rhi+m2pFKZqfO9pytX1clc0katqtsDNupJxFy0xT9wsZSPzM2v1y+/H/zfp5Q==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-qs9z5LqXO/CZC2Lg9SGKpoLU8Rhi+m2pFKZqfO9pytX1clc0katqtsDNupJxFy0xT9wsZSPzM2v1y+/H/zfp5Q==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/token-providers@3.1052.0':
-    resolution:
-      {
-        integrity: sha512-QqZNB3so7UIDxZtroc85TQaLVxdZRFm0eWM1CSR2N+b06as9TOrilvrlTZuj3guYlxMs6yLOgGxnklJ5qMYtTw==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-QqZNB3so7UIDxZtroc85TQaLVxdZRFm0eWM1CSR2N+b06as9TOrilvrlTZuj3guYlxMs6yLOgGxnklJ5qMYtTw==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/types@3.973.9':
-    resolution:
-      {
-        integrity: sha512-kuBfgQVdcz5Bmapc4A13YbpVw/pXkesfhetcFYwbntqas8sF41OHyd4o28+/TG2ZQdHBsv90Lsu5y6oitvYCdg==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-kuBfgQVdcz5Bmapc4A13YbpVw/pXkesfhetcFYwbntqas8sF41OHyd4o28+/TG2ZQdHBsv90Lsu5y6oitvYCdg==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/util-locate-window@3.965.5':
-    resolution:
-      {
-        integrity: sha512-WhlJNNINQB+9qtLtZJcpQdgZw3SCDCpXdUJP7cToGwHbCWCnRckGlc6Bx/OhWwIYFNAn+FIydY8SZ0QmVu3xTQ==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-WhlJNNINQB+9qtLtZJcpQdgZw3SCDCpXdUJP7cToGwHbCWCnRckGlc6Bx/OhWwIYFNAn+FIydY8SZ0QmVu3xTQ==}
+    engines: {node: '>=20.0.0'}
 
   '@aws-sdk/xml-builder@3.972.25':
-    resolution:
-      {
-        integrity: sha512-GH+Kjz4nPKWKHnsiQpnhP1MJdTGIcK4rAka6tzakgjjUkVgNsmPeEbbRAf09SzS1hjGu6duGHCBsxYke0BhHjQ==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-GH+Kjz4nPKWKHnsiQpnhP1MJdTGIcK4rAka6tzakgjjUkVgNsmPeEbbRAf09SzS1hjGu6duGHCBsxYke0BhHjQ==}
+    engines: {node: '>=20.0.0'}
 
   '@aws/lambda-invoke-store@0.2.4':
-    resolution:
-      {
-        integrity: sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ==}
+    engines: {node: '>=18.0.0'}
 
   '@babel/code-frame@7.27.1':
-    resolution:
-      {
-        integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/code-frame@7.28.6':
-    resolution:
-      {
-        integrity: sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/code-frame@7.29.0':
-    resolution:
-      {
-        integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/compat-data@7.28.6':
-    resolution:
-      {
-        integrity: sha512-2lfu57JtzctfIrcGMz992hyLlByuzgIk58+hhGCxjKZ3rWI82NnVLjXcaTqkI2NvlcvOskZaiZ5kjUALo3Lpxg==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-2lfu57JtzctfIrcGMz992hyLlByuzgIk58+hhGCxjKZ3rWI82NnVLjXcaTqkI2NvlcvOskZaiZ5kjUALo3Lpxg==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/core@7.28.6':
-    resolution:
-      {
-        integrity: sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/core@7.29.0':
-    resolution:
-      {
-        integrity: sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/generator@7.29.1':
-    resolution:
-      {
-        integrity: sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-annotate-as-pure@7.27.3':
-    resolution:
-      {
-        integrity: sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-compilation-targets@7.28.6':
-    resolution:
-      {
-        integrity: sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-globals@7.28.0':
-    resolution:
-      {
-        integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-module-imports@7.28.6':
-    resolution:
-      {
-        integrity: sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-module-transforms@7.28.6':
-    resolution:
-      {
-        integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
 
   '@babel/helper-plugin-utils@7.28.6':
-    resolution:
-      {
-        integrity: sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-string-parser@7.27.1':
-    resolution:
-      {
-        integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-validator-identifier@7.28.5':
-    resolution:
-      {
-        integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helper-validator-option@7.27.1':
-    resolution:
-      {
-        integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helpers@7.28.6':
-    resolution:
-      {
-        integrity: sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/helpers@7.29.2':
-    resolution:
-      {
-        integrity: sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/parser@7.29.0':
-    resolution:
-      {
-        integrity: sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==,
-      }
-    engines: { node: '>=6.0.0' }
+    resolution: {integrity: sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==}
+    engines: {node: '>=6.0.0'}
     hasBin: true
 
   '@babel/parser@7.29.3':
-    resolution:
-      {
-        integrity: sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==,
-      }
-    engines: { node: '>=6.0.0' }
+    resolution: {integrity: sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==}
+    engines: {node: '>=6.0.0'}
     hasBin: true
 
   '@babel/plugin-syntax-async-generators@7.8.4':
-    resolution:
-      {
-        integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==,
-      }
+    resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-bigint@7.8.3':
-    resolution:
-      {
-        integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==,
-      }
+    resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-class-properties@7.12.13':
-    resolution:
-      {
-        integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==,
-      }
+    resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-class-static-block@7.14.5':
-    resolution:
-      {
-        integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-import-attributes@7.28.6':
-    resolution:
-      {
-        integrity: sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-import-meta@7.10.4':
-    resolution:
-      {
-        integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==,
-      }
+    resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-json-strings@7.8.3':
-    resolution:
-      {
-        integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==,
-      }
+    resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-jsx@7.28.6':
-    resolution:
-      {
-        integrity: sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-logical-assignment-operators@7.10.4':
-    resolution:
-      {
-        integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==,
-      }
+    resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3':
-    resolution:
-      {
-        integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==,
-      }
+    resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-numeric-separator@7.10.4':
-    resolution:
-      {
-        integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==,
-      }
+    resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-object-rest-spread@7.8.3':
-    resolution:
-      {
-        integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==,
-      }
+    resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-optional-catch-binding@7.8.3':
-    resolution:
-      {
-        integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==,
-      }
+    resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-optional-chaining@7.8.3':
-    resolution:
-      {
-        integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==,
-      }
+    resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-private-property-in-object@7.14.5':
-    resolution:
-      {
-        integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-top-level-await@7.14.5':
-    resolution:
-      {
-        integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-syntax-typescript@7.28.6':
-    resolution:
-      {
-        integrity: sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-transform-react-jsx-self@7.27.1':
-    resolution:
-      {
-        integrity: sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/plugin-transform-react-jsx-source@7.27.1':
-    resolution:
-      {
-        integrity: sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
   '@babel/runtime-corejs3@7.28.4':
-    resolution:
-      {
-        integrity: sha512-h7iEYiW4HebClDEhtvFObtPmIvrd1SSfpI9EhOeKk4CtIK/ngBWFpuhCzhdmRKtg71ylcue+9I6dv54XYO1epQ==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-h7iEYiW4HebClDEhtvFObtPmIvrd1SSfpI9EhOeKk4CtIK/ngBWFpuhCzhdmRKtg71ylcue+9I6dv54XYO1epQ==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/runtime@7.28.4':
-    resolution:
-      {
-        integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/template@7.28.6':
-    resolution:
-      {
-        integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/traverse@7.28.5':
-    resolution:
-      {
-        integrity: sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/traverse@7.28.6':
-    resolution:
-      {
-        integrity: sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/traverse@7.29.0':
-    resolution:
-      {
-        integrity: sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/types@7.28.5':
-    resolution:
-      {
-        integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
+    engines: {node: '>=6.9.0'}
 
   '@babel/types@7.29.0':
-    resolution:
-      {
-        integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
+    engines: {node: '>=6.9.0'}
 
   '@bcoe/v8-coverage@0.2.3':
-    resolution:
-      {
-        integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==,
-      }
+    resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==}
 
   '@constructive-io/fetch@1.1.1':
-    resolution:
-      {
-        integrity: sha512-kpus6sqQwMUTBNpqYvSejG27HJXDucV+BQUNUg3T5U92Qy94Q6of7OhbovICteDMmgcRKCdc5S2e2pXnIY8L5A==,
-      }
+    resolution: {integrity: sha512-kpus6sqQwMUTBNpqYvSejG27HJXDucV+BQUNUg3T5U92Qy94Q6of7OhbovICteDMmgcRKCdc5S2e2pXnIY8L5A==}
 
   '@constructive-io/noble-hashes@0.2.1':
-    resolution:
-      {
-        integrity: sha512-P/C3m4Y9Ywhk7+05aKpg8L7Lkl9Am6AmYMsrMEQ6pRKQA+HIhEutsn9oL99ldsc7gtIt9UEuSHzLRKQvyQCEGQ==,
-      }
+    resolution: {integrity: sha512-P/C3m4Y9Ywhk7+05aKpg8L7Lkl9Am6AmYMsrMEQ6pRKQA+HIhEutsn9oL99ldsc7gtIt9UEuSHzLRKQvyQCEGQ==}
 
   '@cspotcode/source-map-support@0.8.1':
-    resolution:
-      {
-        integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
+    engines: {node: '>=12'}
 
   '@csstools/color-helpers@5.1.0':
-    resolution:
-      {
-        integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
+    engines: {node: '>=18'}
 
   '@csstools/css-calc@2.1.4':
-    resolution:
-      {
-        integrity: sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==}
+    engines: {node: '>=18'}
     peerDependencies:
       '@csstools/css-parser-algorithms': ^3.0.5
       '@csstools/css-tokenizer': ^3.0.4
 
   '@csstools/css-color-parser@3.1.0':
-    resolution:
-      {
-        integrity: sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==}
+    engines: {node: '>=18'}
     peerDependencies:
       '@csstools/css-parser-algorithms': ^3.0.5
       '@csstools/css-tokenizer': ^3.0.4
 
   '@csstools/css-parser-algorithms@3.0.5':
-    resolution:
-      {
-        integrity: sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==}
+    engines: {node: '>=18'}
     peerDependencies:
       '@csstools/css-tokenizer': ^3.0.4
 
   '@csstools/css-tokenizer@3.0.4':
-    resolution:
-      {
-        integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==}
+    engines: {node: '>=18'}
 
   '@dataplan/json@1.0.0':
-    resolution:
-      {
-        integrity: sha512-mSBzlhKTZWeXYq/j8U+8/9sVToeVQW4TYfTaEwZvE6fFHJTIzBK38dgOPTN+Vp/Wk7iiRT+GYd8RWE6aMFpNDg==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-mSBzlhKTZWeXYq/j8U+8/9sVToeVQW4TYfTaEwZvE6fFHJTIzBK38dgOPTN+Vp/Wk7iiRT+GYd8RWE6aMFpNDg==}
+    engines: {node: '>=22'}
     peerDependencies:
       grafast: ^1.0.0-rc.8
 
   '@dataplan/pg@1.0.3':
-    resolution:
-      {
-        integrity: sha512-DdgPF+Mg8KntTAC5lW/4w34s74NLCgBgpbw3+PtBhi2QC66acD7noVWZAgzUx/ATouLE9gUiKqHnva89vcNEjA==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-DdgPF+Mg8KntTAC5lW/4w34s74NLCgBgpbw3+PtBhi2QC66acD7noVWZAgzUx/ATouLE9gUiKqHnva89vcNEjA==}
+    engines: {node: '>=22'}
     peerDependencies:
       '@dataplan/json': 1.0.0
       grafast: ^1.0.2
@@ -4269,662 +4030,422 @@ packages:
         optional: true
 
   '@emnapi/core@1.10.0':
-    resolution:
-      {
-        integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==,
-      }
+    resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==}
 
   '@emnapi/core@1.7.1':
-    resolution:
-      {
-        integrity: sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==,
-      }
+    resolution: {integrity: sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==}
 
   '@emnapi/runtime@1.10.0':
-    resolution:
-      {
-        integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==,
-      }
+    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
 
   '@emnapi/runtime@1.7.1':
-    resolution:
-      {
-        integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==,
-      }
+    resolution: {integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==}
 
   '@emnapi/wasi-threads@1.1.0':
-    resolution:
-      {
-        integrity: sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==,
-      }
+    resolution: {integrity: sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==}
 
   '@emnapi/wasi-threads@1.2.1':
-    resolution:
-      {
-        integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==,
-      }
+    resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==}
 
   '@emotion/is-prop-valid@1.4.0':
-    resolution:
-      {
-        integrity: sha512-QgD4fyscGcbbKwJmqNvUMSE02OsHUa+lAWKdEUIJKgqe5IwRSKd7+KhibEWdaKwgjLj0DRSHA9biAIqGBk05lw==,
-      }
+    resolution: {integrity: sha512-QgD4fyscGcbbKwJmqNvUMSE02OsHUa+lAWKdEUIJKgqe5IwRSKd7+KhibEWdaKwgjLj0DRSHA9biAIqGBk05lw==}
 
   '@emotion/memoize@0.9.0':
-    resolution:
-      {
-        integrity: sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==,
-      }
+    resolution: {integrity: sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==}
 
   '@emotion/stylis@0.8.5':
-    resolution:
-      {
-        integrity: sha512-h6KtPihKFn3T9fuIrwvXXUOwlx3rfUvfZIcP5a6rh8Y7zjE3O06hT5Ss4S/YI1AYhuZ1kjaE/5EaOOI2NqSylQ==,
-      }
+    resolution: {integrity: sha512-h6KtPihKFn3T9fuIrwvXXUOwlx3rfUvfZIcP5a6rh8Y7zjE3O06hT5Ss4S/YI1AYhuZ1kjaE/5EaOOI2NqSylQ==}
 
   '@emotion/unitless@0.7.5':
-    resolution:
-      {
-        integrity: sha512-OWORNpfjMsSSUBVrRBVGECkhWcULOAJz9ZW8uK9qgxD+87M7jHRcvh/A96XXNhXTLmKcoYSQtBEX7lHMO7YRwg==,
-      }
+    resolution: {integrity: sha512-OWORNpfjMsSSUBVrRBVGECkhWcULOAJz9ZW8uK9qgxD+87M7jHRcvh/A96XXNhXTLmKcoYSQtBEX7lHMO7YRwg==}
 
   '@esbuild/aix-ppc64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==}
+    engines: {node: '>=18'}
     cpu: [ppc64]
     os: [aix]
 
   '@esbuild/aix-ppc64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==}
+    engines: {node: '>=18'}
     cpu: [ppc64]
     os: [aix]
 
   '@esbuild/android-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [android]
 
   '@esbuild/android-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [android]
 
   '@esbuild/android-arm@0.25.12':
-    resolution:
-      {
-        integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==}
+    engines: {node: '>=18'}
     cpu: [arm]
     os: [android]
 
   '@esbuild/android-arm@0.27.2':
-    resolution:
-      {
-        integrity: sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==}
+    engines: {node: '>=18'}
     cpu: [arm]
     os: [android]
 
   '@esbuild/android-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [android]
 
   '@esbuild/android-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [android]
 
   '@esbuild/darwin-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [darwin]
 
   '@esbuild/darwin-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [darwin]
 
   '@esbuild/darwin-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [darwin]
 
   '@esbuild/darwin-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [darwin]
 
   '@esbuild/freebsd-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [freebsd]
 
   '@esbuild/freebsd-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [freebsd]
 
   '@esbuild/freebsd-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [freebsd]
 
   '@esbuild/freebsd-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [freebsd]
 
   '@esbuild/linux-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [linux]
 
   '@esbuild/linux-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [linux]
 
   '@esbuild/linux-arm@0.25.12':
-    resolution:
-      {
-        integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==}
+    engines: {node: '>=18'}
     cpu: [arm]
     os: [linux]
 
   '@esbuild/linux-arm@0.27.2':
-    resolution:
-      {
-        integrity: sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==}
+    engines: {node: '>=18'}
     cpu: [arm]
     os: [linux]
 
   '@esbuild/linux-ia32@0.25.12':
-    resolution:
-      {
-        integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==}
+    engines: {node: '>=18'}
     cpu: [ia32]
     os: [linux]
 
   '@esbuild/linux-ia32@0.27.2':
-    resolution:
-      {
-        integrity: sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==}
+    engines: {node: '>=18'}
     cpu: [ia32]
     os: [linux]
 
   '@esbuild/linux-loong64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==}
+    engines: {node: '>=18'}
     cpu: [loong64]
     os: [linux]
 
   '@esbuild/linux-loong64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==}
+    engines: {node: '>=18'}
     cpu: [loong64]
     os: [linux]
 
   '@esbuild/linux-mips64el@0.25.12':
-    resolution:
-      {
-        integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==}
+    engines: {node: '>=18'}
     cpu: [mips64el]
     os: [linux]
 
   '@esbuild/linux-mips64el@0.27.2':
-    resolution:
-      {
-        integrity: sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==}
+    engines: {node: '>=18'}
     cpu: [mips64el]
     os: [linux]
 
   '@esbuild/linux-ppc64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==}
+    engines: {node: '>=18'}
     cpu: [ppc64]
     os: [linux]
 
   '@esbuild/linux-ppc64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==}
+    engines: {node: '>=18'}
     cpu: [ppc64]
     os: [linux]
 
   '@esbuild/linux-riscv64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==}
+    engines: {node: '>=18'}
     cpu: [riscv64]
     os: [linux]
 
   '@esbuild/linux-riscv64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==}
+    engines: {node: '>=18'}
     cpu: [riscv64]
     os: [linux]
 
   '@esbuild/linux-s390x@0.25.12':
-    resolution:
-      {
-        integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==}
+    engines: {node: '>=18'}
     cpu: [s390x]
     os: [linux]
 
   '@esbuild/linux-s390x@0.27.2':
-    resolution:
-      {
-        integrity: sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==}
+    engines: {node: '>=18'}
     cpu: [s390x]
     os: [linux]
 
   '@esbuild/linux-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [linux]
 
   '@esbuild/linux-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [linux]
 
   '@esbuild/netbsd-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [netbsd]
 
   '@esbuild/netbsd-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [netbsd]
 
   '@esbuild/netbsd-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [netbsd]
 
   '@esbuild/netbsd-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [netbsd]
 
   '@esbuild/openbsd-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [openbsd]
 
   '@esbuild/openbsd-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [openbsd]
 
   '@esbuild/openbsd-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [openbsd]
 
   '@esbuild/openbsd-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [openbsd]
 
   '@esbuild/openharmony-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [openharmony]
 
   '@esbuild/openharmony-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [openharmony]
 
   '@esbuild/sunos-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [sunos]
 
   '@esbuild/sunos-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [sunos]
 
   '@esbuild/win32-arm64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [win32]
 
   '@esbuild/win32-arm64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==}
+    engines: {node: '>=18'}
     cpu: [arm64]
     os: [win32]
 
   '@esbuild/win32-ia32@0.25.12':
-    resolution:
-      {
-        integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==}
+    engines: {node: '>=18'}
     cpu: [ia32]
     os: [win32]
 
   '@esbuild/win32-ia32@0.27.2':
-    resolution:
-      {
-        integrity: sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==}
+    engines: {node: '>=18'}
     cpu: [ia32]
     os: [win32]
 
   '@esbuild/win32-x64@0.25.12':
-    resolution:
-      {
-        integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [win32]
 
   '@esbuild/win32-x64@0.27.2':
-    resolution:
-      {
-        integrity: sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==}
+    engines: {node: '>=18'}
     cpu: [x64]
     os: [win32]
 
   '@eslint-community/eslint-utils@4.9.0':
-    resolution:
-      {
-        integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==,
-      }
-    engines: { node: ^12.22.0 || ^14.17.0 || >=16.0.0 }
+    resolution: {integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
 
   '@eslint-community/eslint-utils@4.9.1':
-    resolution:
-      {
-        integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==,
-      }
-    engines: { node: ^12.22.0 || ^14.17.0 || >=16.0.0 }
+    resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
 
   '@eslint-community/regexpp@4.12.2':
-    resolution:
-      {
-        integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==,
-      }
-    engines: { node: ^12.0.0 || ^14.0.0 || >=16.0.0 }
+    resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
 
   '@eslint/config-array@0.21.1':
-    resolution:
-      {
-        integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/config-helpers@0.4.2':
-    resolution:
-      {
-        integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/core@0.17.0':
-    resolution:
-      {
-        integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/eslintrc@3.3.3':
-    resolution:
-      {
-        integrity: sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/js@9.39.2':
-    resolution:
-      {
-        integrity: sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/object-schema@2.1.7':
-    resolution:
-      {
-        integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/plugin-kit@0.4.1':
-    resolution:
-      {
-        integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@floating-ui/core@1.7.5':
-    resolution:
-      {
-        integrity: sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==,
-      }
+    resolution: {integrity: sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==}
 
   '@floating-ui/dom@1.7.6':
-    resolution:
-      {
-        integrity: sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==,
-      }
+    resolution: {integrity: sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==}
 
   '@floating-ui/react-dom@2.1.8':
-    resolution:
-      {
-        integrity: sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==,
-      }
+    resolution: {integrity: sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==}
     peerDependencies:
       react: '>=16.8.0'
       react-dom: '>=16.8.0'
 
   '@floating-ui/react@0.26.28':
-    resolution:
-      {
-        integrity: sha512-yORQuuAtVpiRjpMhdc0wJj06b9JFjrYF4qp96j++v2NBpbi6SEGF7donUJ3TMieerQ6qVkAv1tgr7L4r5roTqw==,
-      }
+    resolution: {integrity: sha512-yORQuuAtVpiRjpMhdc0wJj06b9JFjrYF4qp96j++v2NBpbi6SEGF7donUJ3TMieerQ6qVkAv1tgr7L4r5roTqw==}
     peerDependencies:
       react: '>=16.8.0'
       react-dom: '>=16.8.0'
 
   '@floating-ui/utils@0.2.11':
-    resolution:
-      {
-        integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==,
-      }
+    resolution: {integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==}
 
   '@graphile-contrib/pg-many-to-many@2.0.0-rc.2':
-    resolution:
-      {
-        integrity: sha512-aPu/oPWIsljTmlj58UNy95+JzXwHrClQA51bvfZUgj3l7kaUiwCCBYCFql2nSrMwdlFgexphs3faJbHiqsEDrw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-aPu/oPWIsljTmlj58UNy95+JzXwHrClQA51bvfZUgj3l7kaUiwCCBYCFql2nSrMwdlFgexphs3faJbHiqsEDrw==}
+    engines: {node: '>=10'}
 
   '@graphile/lru@5.0.0':
-    resolution:
-      {
-        integrity: sha512-NeRBDdUd/l4H284HrYL2/wNHv/FmW5stAMPFAiBZanLHwq9J3suZTtyN5CwTxUFA/vgqzu0B1/9XtIEaJYEKig==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-NeRBDdUd/l4H284HrYL2/wNHv/FmW5stAMPFAiBZanLHwq9J3suZTtyN5CwTxUFA/vgqzu0B1/9XtIEaJYEKig==}
+    engines: {node: '>=22'}
 
   '@graphiql/plugin-doc-explorer@0.4.1':
-    resolution:
-      {
-        integrity: sha512-+ram1dDDGMqJn/f9n5I8E6grTvxcM9JZYt/HhtYLuCvkN8kERI6/E3zBHBshhIUnQZoXioZ03fAzXg7JOn0Kyg==,
-      }
+    resolution: {integrity: sha512-+ram1dDDGMqJn/f9n5I8E6grTvxcM9JZYt/HhtYLuCvkN8kERI6/E3zBHBshhIUnQZoXioZ03fAzXg7JOn0Kyg==}
     peerDependencies:
       '@graphiql/react': ^0.37.0
       graphql: 16.13.0
@@ -4933,10 +4454,7 @@ packages:
       react-dom: ^18 || ^19
 
   '@graphiql/plugin-history@0.4.1':
-    resolution:
-      {
-        integrity: sha512-UyGI/Nm5tzKNMB71li41p6TfkthLqHkmNi9CgHzAM1zKgPIrtSq7Q8WCWKHLOEB5n4/8X8sXFeyQfHgnGYTXYg==,
-      }
+    resolution: {integrity: sha512-UyGI/Nm5tzKNMB71li41p6TfkthLqHkmNi9CgHzAM1zKgPIrtSq7Q8WCWKHLOEB5n4/8X8sXFeyQfHgnGYTXYg==}
     peerDependencies:
       '@graphiql/react': ^0.37.0
       react: ^18 || ^19
@@ -4944,10 +4462,7 @@ packages:
       react-dom: ^18 || ^19
 
   '@graphiql/react@0.37.3':
-    resolution:
-      {
-        integrity: sha512-rNJjwsYGhcZRdZ2FnyU6ss06xQaZ4UordyvOhp7+b/bEqQiEBpMOLJjuUr48Z6T7zEbZBnzCJpIJyXNqlcfQeA==,
-      }
+    resolution: {integrity: sha512-rNJjwsYGhcZRdZ2FnyU6ss06xQaZ4UordyvOhp7+b/bEqQiEBpMOLJjuUr48Z6T7zEbZBnzCJpIJyXNqlcfQeA==}
     peerDependencies:
       graphql: 16.13.0
       react: ^18 || ^19
@@ -4955,10 +4470,7 @@ packages:
       react-dom: ^18 || ^19
 
   '@graphiql/toolkit@0.11.3':
-    resolution:
-      {
-        integrity: sha512-Glf0fK1cdHLNq52UWPzfSrYIJuNxy8h4451Pw1ZVpJ7dtU+tm7GVVC64UjEDQ/v2j3fnG4cX8jvR75IvfL6nzQ==,
-      }
+    resolution: {integrity: sha512-Glf0fK1cdHLNq52UWPzfSrYIJuNxy8h4451Pw1ZVpJ7dtU+tm7GVVC64UjEDQ/v2j3fnG4cX8jvR75IvfL6nzQ==}
     peerDependencies:
       graphql: 16.13.0
       graphql-ws: '>= 4.5.0'
@@ -4967,64 +4479,40 @@ packages:
         optional: true
 
   '@graphql-typed-document-node/core@3.2.0':
-    resolution:
-      {
-        integrity: sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ==,
-      }
+    resolution: {integrity: sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ==}
     peerDependencies:
       graphql: 16.13.0
 
   '@headlessui/react@2.2.9':
-    resolution:
-      {
-        integrity: sha512-Mb+Un58gwBn0/yWZfyrCh0TJyurtT+dETj7YHleylHk5od3dv2XqETPGWMyQ5/7sYN7oWdyM1u9MvC0OC8UmzQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-Mb+Un58gwBn0/yWZfyrCh0TJyurtT+dETj7YHleylHk5od3dv2XqETPGWMyQ5/7sYN7oWdyM1u9MvC0OC8UmzQ==}
+    engines: {node: '>=10'}
     peerDependencies:
       react: ^18 || ^19 || ^19.0.0-rc
       react-dom: ^18 || ^19 || ^19.0.0-rc
 
   '@humanfs/core@0.19.1':
-    resolution:
-      {
-        integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==,
-      }
-    engines: { node: '>=18.18.0' }
+    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+    engines: {node: '>=18.18.0'}
 
   '@humanfs/node@0.16.7':
-    resolution:
-      {
-        integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==,
-      }
-    engines: { node: '>=18.18.0' }
+    resolution: {integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==}
+    engines: {node: '>=18.18.0'}
 
   '@humanwhocodes/module-importer@1.0.1':
-    resolution:
-      {
-        integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==,
-      }
-    engines: { node: '>=12.22' }
+    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
+    engines: {node: '>=12.22'}
 
   '@humanwhocodes/retry@0.4.3':
-    resolution:
-      {
-        integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==,
-      }
-    engines: { node: '>=18.18' }
+    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
+    engines: {node: '>=18.18'}
 
   '@hutson/parse-repository-url@3.0.2':
-    resolution:
-      {
-        integrity: sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==}
+    engines: {node: '>=6.9.0'}
 
   '@inquirer/external-editor@1.0.3':
-    resolution:
-      {
-        integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==}
+    engines: {node: '>=18'}
     peerDependencies:
       '@types/node': '>=18'
     peerDependenciesMeta:
@@ -5032,10 +4520,7 @@ packages:
         optional: true
 
   '@inquirerer/test@1.4.3':
-    resolution:
-      {
-        integrity: sha512-UzT7jvH3s6pGe3jen3YXk6oEb5V2NIxDS1XQ0EPYlqbNbe0ElKqAO4b2J0tpGr0fg02/FNOmuLPmTuDefUpr0w==,
-      }
+    resolution: {integrity: sha512-UzT7jvH3s6pGe3jen3YXk6oEb5V2NIxDS1XQ0EPYlqbNbe0ElKqAO4b2J0tpGr0fg02/FNOmuLPmTuDefUpr0w==}
     peerDependencies:
       jest: '>=29.0.0'
     peerDependenciesMeta:
@@ -5043,58 +4528,34 @@ packages:
         optional: true
 
   '@inquirerer/utils@3.3.9':
-    resolution:
-      {
-        integrity: sha512-3XOsanmowNclC+vWu1Co06nidwcU9SRN+f0dHDLULEBQedLMgDrmU2KJ0ZsBJEjJS91J7C6QELozxzRdtZMZMA==,
-      }
+    resolution: {integrity: sha512-3XOsanmowNclC+vWu1Co06nidwcU9SRN+f0dHDLULEBQedLMgDrmU2KJ0ZsBJEjJS91J7C6QELozxzRdtZMZMA==}
 
   '@isaacs/cliui@8.0.2':
-    resolution:
-      {
-        integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
+    engines: {node: '>=12'}
 
   '@isaacs/cliui@9.0.0':
-    resolution:
-      {
-        integrity: sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==}
+    engines: {node: '>=18'}
 
   '@isaacs/string-locale-compare@1.1.0':
-    resolution:
-      {
-        integrity: sha512-SQ7Kzhh9+D+ZW9MA0zkYv3VXhIDNx+LzM6EJ+/65I3QY+enU6Itte7E5XX7EWrqLW2FN4n06GWzBnPoC3th2aQ==,
-      }
+    resolution: {integrity: sha512-SQ7Kzhh9+D+ZW9MA0zkYv3VXhIDNx+LzM6EJ+/65I3QY+enU6Itte7E5XX7EWrqLW2FN4n06GWzBnPoC3th2aQ==}
 
   '@istanbuljs/load-nyc-config@1.1.0':
-    resolution:
-      {
-        integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==}
+    engines: {node: '>=8'}
 
   '@istanbuljs/schema@0.1.6':
-    resolution:
-      {
-        integrity: sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw==}
+    engines: {node: '>=8'}
 
   '@jest/console@30.4.1':
-    resolution:
-      {
-        integrity: sha512-v3bhyxUh9Hgmo5p6hAOXe14/R3ZxZDOsvHleh4B07z3m/x4/ngPUXEm9XwK4sF4u+f+P2ORb0Ge+MgpaqRMVDA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-v3bhyxUh9Hgmo5p6hAOXe14/R3ZxZDOsvHleh4B07z3m/x4/ngPUXEm9XwK4sF4u+f+P2ORb0Ge+MgpaqRMVDA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/core@30.4.2':
-    resolution:
-      {
-        integrity: sha512-TZJA6cPJUFxoWhxaLo8t0VX/MZX2wPWr0uIDvLSHIvN4gu9h02vSzqI2kBADG1ExqQlC+cY09xKMSreivvrChQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-TZJA6cPJUFxoWhxaLo8t0VX/MZX2wPWr0uIDvLSHIvN4gu9h02vSzqI2kBADG1ExqQlC+cY09xKMSreivvrChQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
     peerDependenciesMeta:
@@ -5102,25 +4563,16 @@ packages:
         optional: true
 
   '@jest/diff-sequences@30.0.1':
-    resolution:
-      {
-        integrity: sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/diff-sequences@30.4.0':
-    resolution:
-      {
-        integrity: sha512-zOpzlfUs45l6u7jm39qr87JCHUDsaeCtvL+kQe/Vn9jSnRB4/5IPXISm0h9I1vZW/o00Kn4UTJ2MOlhnUGwv3g==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-zOpzlfUs45l6u7jm39qr87JCHUDsaeCtvL+kQe/Vn9jSnRB4/5IPXISm0h9I1vZW/o00Kn4UTJ2MOlhnUGwv3g==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/environment-jsdom-abstract@30.4.1':
-    resolution:
-      {
-        integrity: sha512-dSlKrqug3siYNHVnjwIldShY12wAH3spwRltO/+8VOjg0X+xEq7vOs3DbBs4LRKsu7OH+NUb9kuZUNBF9Ho3TA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-dSlKrqug3siYNHVnjwIldShY12wAH3spwRltO/+8VOjg0X+xEq7vOs3DbBs4LRKsu7OH+NUb9kuZUNBF9Ho3TA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       canvas: ^3.0.0
       jsdom: '*'
@@ -5129,74 +4581,44 @@ packages:
         optional: true
 
   '@jest/environment@30.4.1':
-    resolution:
-      {
-        integrity: sha512-AK9yNRqgKxiabqMoe4oW+3/TSSeV8vkdC7BGaxZdU0AFXfOpofTLqdru2GXKZghP3sdgwE9XXpnVwfZ8JnFV4w==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-AK9yNRqgKxiabqMoe4oW+3/TSSeV8vkdC7BGaxZdU0AFXfOpofTLqdru2GXKZghP3sdgwE9XXpnVwfZ8JnFV4w==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/expect-utils@30.2.0':
-    resolution:
-      {
-        integrity: sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/expect-utils@30.4.1':
-    resolution:
-      {
-        integrity: sha512-ZBn5CglH8fBsQsvs4VWNzD4aWfUYks+IdOOQU3MEK71ol/BcVm+P+rtb1KpiFBpSWSCE27uOahyyf1vfqOVbcQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-ZBn5CglH8fBsQsvs4VWNzD4aWfUYks+IdOOQU3MEK71ol/BcVm+P+rtb1KpiFBpSWSCE27uOahyyf1vfqOVbcQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/expect@30.4.1':
-    resolution:
-      {
-        integrity: sha512-ginrj6TMgh2GshLUGCjO94Ptx9HhdZA/I6A9iUfyeLKFtdAjnKzHDgzgP9HYQgbxM1lbXScQ2eUBz2lGeVDPWA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-ginrj6TMgh2GshLUGCjO94Ptx9HhdZA/I6A9iUfyeLKFtdAjnKzHDgzgP9HYQgbxM1lbXScQ2eUBz2lGeVDPWA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/fake-timers@30.4.1':
-    resolution:
-      {
-        integrity: sha512-iW5umdmfPeWzehrVhugFQZqCchSCud5S1l2YT0O9ZhjRR0ExclANDZkiSBwzqtnlOn0J1JXvO+HZ6rkuyOVOgQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-iW5umdmfPeWzehrVhugFQZqCchSCud5S1l2YT0O9ZhjRR0ExclANDZkiSBwzqtnlOn0J1JXvO+HZ6rkuyOVOgQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/get-type@30.1.0':
-    resolution:
-      {
-        integrity: sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/globals@30.4.1':
-    resolution:
-      {
-        integrity: sha512-ZbuY4cmXC8DkxYjfvT2DbcHWL2T6vmsMhXCDcmTB2T0y0gaezBI77ufq5ZAIdcRkYZ7NEQEDg1xFeKbxUJ5v5Q==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-ZbuY4cmXC8DkxYjfvT2DbcHWL2T6vmsMhXCDcmTB2T0y0gaezBI77ufq5ZAIdcRkYZ7NEQEDg1xFeKbxUJ5v5Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/pattern@30.0.1':
-    resolution:
-      {
-        integrity: sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/pattern@30.4.0':
-    resolution:
-      {
-        integrity: sha512-RAWn3+f9u8BsHijKJ71uHcFp6vmyEt6VvoWXkl6hKF3qVIuWNmudVjg12DlBPGup/frIl5UcUlH5HfEuvHpEXg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-RAWn3+f9u8BsHijKJ71uHcFp6vmyEt6VvoWXkl6hKF3qVIuWNmudVjg12DlBPGup/frIl5UcUlH5HfEuvHpEXg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/reporters@30.4.1':
-    resolution:
-      {
-        integrity: sha512-/SnkPCzEQpUaBH81kjdEdDdo2WZl5hxw+BmLDGWjRkm8o7XlhjwsU36cqwe5PGBE5WYpBvDzRSdXx9rbGuJtNA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-/SnkPCzEQpUaBH81kjdEdDdo2WZl5hxw+BmLDGWjRkm8o7XlhjwsU36cqwe5PGBE5WYpBvDzRSdXx9rbGuJtNA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
     peerDependenciesMeta:
@@ -5204,872 +4626,527 @@ packages:
         optional: true
 
   '@jest/schemas@29.6.3':
-    resolution:
-      {
-        integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==,
-      }
-    engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 }
+    resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
   '@jest/schemas@30.0.5':
-    resolution:
-      {
-        integrity: sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/schemas@30.4.1':
-    resolution:
-      {
-        integrity: sha512-i6b4qw5qnP8c5FEeBJg/uZQ4ddrkN6Ca8qISJh0pr7a5hfn3h3v5x60BEbOC7OYAGZNMs1LfFLwnW2CuK8F57Q==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-i6b4qw5qnP8c5FEeBJg/uZQ4ddrkN6Ca8qISJh0pr7a5hfn3h3v5x60BEbOC7OYAGZNMs1LfFLwnW2CuK8F57Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/snapshot-utils@30.4.1':
-    resolution:
-      {
-        integrity: sha512-ObY4ljvQ95mt6iwKtVLetR/4yXiAgl3H4nJxhztr0MTjrN97TwDYrnCp/kF60Ec9HdhkWTHSu+Hg05aXfngpOA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-ObY4ljvQ95mt6iwKtVLetR/4yXiAgl3H4nJxhztr0MTjrN97TwDYrnCp/kF60Ec9HdhkWTHSu+Hg05aXfngpOA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/source-map@30.0.1':
-    resolution:
-      {
-        integrity: sha512-MIRWMUUR3sdbP36oyNyhbThLHyJ2eEDClPCiHVbrYAe5g3CHRArIVpBw7cdSB5fr+ofSfIb2Tnsw8iEHL0PYQg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-MIRWMUUR3sdbP36oyNyhbThLHyJ2eEDClPCiHVbrYAe5g3CHRArIVpBw7cdSB5fr+ofSfIb2Tnsw8iEHL0PYQg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/test-result@30.4.1':
-    resolution:
-      {
-        integrity: sha512-/ZG7pgEiOmmWkN9TplKbOu4id2N5lh7FHwRwlkgBVAzGdRH+OkkQ8wX/kIxg4zmd3ZQvAL1RwL2yWsvNYYECTw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-/ZG7pgEiOmmWkN9TplKbOu4id2N5lh7FHwRwlkgBVAzGdRH+OkkQ8wX/kIxg4zmd3ZQvAL1RwL2yWsvNYYECTw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/test-sequencer@30.4.1':
-    resolution:
-      {
-        integrity: sha512-PeYE+4td5rKjoRPxztObrXU+H8hsjZfxKMXOcmrr34JerSyB/ROOxbbicz8B7A5j9R9VayDnVPvBmedqCsFCdw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-PeYE+4td5rKjoRPxztObrXU+H8hsjZfxKMXOcmrr34JerSyB/ROOxbbicz8B7A5j9R9VayDnVPvBmedqCsFCdw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/transform@30.4.1':
-    resolution:
-      {
-        integrity: sha512-Wz0LyktlTvRefoymh+n64hQ84KNXsRGcwdoZ8CSa0Ea+fgYcHZlnk+hDP7v2MS7il2bQ5uTEIxf4/NNfhMN4KQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-Wz0LyktlTvRefoymh+n64hQ84KNXsRGcwdoZ8CSa0Ea+fgYcHZlnk+hDP7v2MS7il2bQ5uTEIxf4/NNfhMN4KQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/types@26.6.2':
-    resolution:
-      {
-        integrity: sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ==,
-      }
-    engines: { node: '>= 10.14.2' }
+    resolution: {integrity: sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ==}
+    engines: {node: '>= 10.14.2'}
 
   '@jest/types@30.2.0':
-    resolution:
-      {
-        integrity: sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jest/types@30.4.1':
-    resolution:
-      {
-        integrity: sha512-f1x/vJXIfjOlEmejYpbkbgw1gOqpPECwMvMEtBqe47j7H2Hg8h8w3o3ikhSXq3MI15kg+oQ0exWO0uCtTNJLoQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-f1x/vJXIfjOlEmejYpbkbgw1gOqpPECwMvMEtBqe47j7H2Hg8h8w3o3ikhSXq3MI15kg+oQ0exWO0uCtTNJLoQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   '@jridgewell/gen-mapping@0.3.13':
-    resolution:
-      {
-        integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==,
-      }
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
 
   '@jridgewell/remapping@2.3.5':
-    resolution:
-      {
-        integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==,
-      }
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
 
   '@jridgewell/resolve-uri@3.1.2':
-    resolution:
-      {
-        integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==,
-      }
-    engines: { node: '>=6.0.0' }
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
 
   '@jridgewell/sourcemap-codec@1.5.5':
-    resolution:
-      {
-        integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==,
-      }
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
 
   '@jridgewell/trace-mapping@0.3.31':
-    resolution:
-      {
-        integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==,
-      }
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
   '@jridgewell/trace-mapping@0.3.9':
-    resolution:
-      {
-        integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==,
-      }
+    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
 
   '@launchql/mjml@0.1.1':
-    resolution:
-      {
-        integrity: sha512-6+OEmECuu5atRZ43ovsMfFs+T4NWNaKbzNG0uA8HYaBSn3kWR7GH3QnmL3lCIeymLtvgua8aZChYvg6SxrQdnw==,
-      }
+    resolution: {integrity: sha512-6+OEmECuu5atRZ43ovsMfFs+T4NWNaKbzNG0uA8HYaBSn3kWR7GH3QnmL3lCIeymLtvgua8aZChYvg6SxrQdnw==}
     peerDependencies:
       react: '>=16'
       react-dom: '>=16'
 
   '@launchql/protobufjs@7.2.6':
-    resolution:
-      {
-        integrity: sha512-vwi1nG2/heVFsIMHQU1KxTjUp5c757CTtRAZn/jutApCkFlle1iv8tzM/DHlSZJKDldxaYqnNYTg0pTyp8Bbtg==,
-      }
-    engines: { node: '>=12.0.0' }
+    resolution: {integrity: sha512-vwi1nG2/heVFsIMHQU1KxTjUp5c757CTtRAZn/jutApCkFlle1iv8tzM/DHlSZJKDldxaYqnNYTg0pTyp8Bbtg==}
+    engines: {node: '>=12.0.0'}
 
   '@launchql/styled-email@0.1.0':
-    resolution:
-      {
-        integrity: sha512-ISjzsY+3EOH/qAKHPq3evw9QmmEyA8Vw+0pUf+Zf8l4/rAHJJKrSa/uPiaUf2Abi8yAZKyx2uyaZq4ExNNkD+w==,
-      }
+    resolution: {integrity: sha512-ISjzsY+3EOH/qAKHPq3evw9QmmEyA8Vw+0pUf+Zf8l4/rAHJJKrSa/uPiaUf2Abi8yAZKyx2uyaZq4ExNNkD+w==}
     peerDependencies:
       react: '>=16'
       react-dom: '>=16'
 
   '@lerna/create@8.2.4':
-    resolution:
-      {
-        integrity: sha512-A8AlzetnS2WIuhijdAzKUyFpR5YbLLfV3luQ4lzBgIBgRfuoBDZeF+RSZPhra+7A6/zTUlrbhKZIOi/MNhqgvQ==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-A8AlzetnS2WIuhijdAzKUyFpR5YbLLfV3luQ4lzBgIBgRfuoBDZeF+RSZPhra+7A6/zTUlrbhKZIOi/MNhqgvQ==}
+    engines: {node: '>=18.0.0'}
     deprecated: This package is an implementation detail of Lerna and is no longer published separately.
 
   '@n1ru4l/push-pull-async-iterable-iterator@3.2.0':
-    resolution:
-      {
-        integrity: sha512-3fkKj25kEjsfObL6IlKPAlHYPq/oYwUkkQ03zsTTiDjD7vg/RxjdiLeCydqtxHZP0JgsXL3D/X5oAkMGzuUp/Q==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-3fkKj25kEjsfObL6IlKPAlHYPq/oYwUkkQ03zsTTiDjD7vg/RxjdiLeCydqtxHZP0JgsXL3D/X5oAkMGzuUp/Q==}
+    engines: {node: '>=12'}
 
   '@napi-rs/wasm-runtime@0.2.4':
-    resolution:
-      {
-        integrity: sha512-9zESzOO5aDByvhIAsOy9TbpZ0Ur2AJbUI7UT73kcUTS2mxAMHOBaa1st/jAymNoCtvrit99kkzT1FZuXVcgfIQ==,
-      }
+    resolution: {integrity: sha512-9zESzOO5aDByvhIAsOy9TbpZ0Ur2AJbUI7UT73kcUTS2mxAMHOBaa1st/jAymNoCtvrit99kkzT1FZuXVcgfIQ==}
 
   '@napi-rs/wasm-runtime@1.1.4':
-    resolution:
-      {
-        integrity: sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==,
-      }
+    resolution: {integrity: sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==}
     peerDependencies:
       '@emnapi/core': ^1.7.1
       '@emnapi/runtime': ^1.7.1
 
   '@noble/hashes@1.8.0':
-    resolution:
-      {
-        integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==,
-      }
-    engines: { node: ^14.21.3 || >=16 }
+    resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==}
+    engines: {node: ^14.21.3 || >=16}
 
   '@nodable/entities@2.1.0':
-    resolution:
-      {
-        integrity: sha512-nyT7T3nbMyBI/lvr6L5TyWbFJAI9FTgVRakNoBqCD+PmID8DzFrrNdLLtHMwMszOtqZa8PAOV24ZqDnQrhQINA==,
-      }
+    resolution: {integrity: sha512-nyT7T3nbMyBI/lvr6L5TyWbFJAI9FTgVRakNoBqCD+PmID8DzFrrNdLLtHMwMszOtqZa8PAOV24ZqDnQrhQINA==}
 
   '@nodelib/fs.scandir@2.1.5':
-    resolution:
-      {
-        integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
 
   '@nodelib/fs.stat@2.0.5':
-    resolution:
-      {
-        integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
 
   '@nodelib/fs.walk@1.2.8':
-    resolution:
-      {
-        integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
 
   '@npmcli/agent@2.2.2':
-    resolution:
-      {
-        integrity: sha512-OrcNPXdpSl9UX7qPVRWbmWMCSXrcDa2M9DvrbOTj7ao1S4PlqVFYv9/yLKMkrJKZ/V5A/kDBC690or307i26Og==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-OrcNPXdpSl9UX7qPVRWbmWMCSXrcDa2M9DvrbOTj7ao1S4PlqVFYv9/yLKMkrJKZ/V5A/kDBC690or307i26Og==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@npmcli/arborist@7.5.4':
-    resolution:
-      {
-        integrity: sha512-nWtIc6QwwoUORCRNzKx4ypHqCk3drI+5aeYdMTQQiRCcn4lOOgfQh7WyZobGYTxXPSq1VwV53lkpN/BRlRk08g==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-nWtIc6QwwoUORCRNzKx4ypHqCk3drI+5aeYdMTQQiRCcn4lOOgfQh7WyZobGYTxXPSq1VwV53lkpN/BRlRk08g==}
+    engines: {node: ^16.14.0 || >=18.0.0}
     hasBin: true
 
   '@npmcli/fs@3.1.1':
-    resolution:
-      {
-        integrity: sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   '@npmcli/git@5.0.8':
-    resolution:
-      {
-        integrity: sha512-liASfw5cqhjNW9UFd+ruwwdEf/lbOAQjLL2XY2dFW/bkJheXDYZgOyul/4gVvEV4BWkTXjYGmDqMw9uegdbJNQ==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-liASfw5cqhjNW9UFd+ruwwdEf/lbOAQjLL2XY2dFW/bkJheXDYZgOyul/4gVvEV4BWkTXjYGmDqMw9uegdbJNQ==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@npmcli/installed-package-contents@2.1.0':
-    resolution:
-      {
-        integrity: sha512-c8UuGLeZpm69BryRykLuKRyKFZYJsZSCT4aVY5ds4omyZqJ172ApzgfKJ5eV/r3HgLdUYgFVe54KSFVjKoe27w==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-c8UuGLeZpm69BryRykLuKRyKFZYJsZSCT4aVY5ds4omyZqJ172ApzgfKJ5eV/r3HgLdUYgFVe54KSFVjKoe27w==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
     hasBin: true
 
   '@npmcli/map-workspaces@3.0.6':
-    resolution:
-      {
-        integrity: sha512-tkYs0OYnzQm6iIRdfy+LcLBjcKuQCeE5YLb8KnrIlutJfheNaPvPpgoFEyEFgbjzl5PLZ3IA/BWAwRU0eHuQDA==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-tkYs0OYnzQm6iIRdfy+LcLBjcKuQCeE5YLb8KnrIlutJfheNaPvPpgoFEyEFgbjzl5PLZ3IA/BWAwRU0eHuQDA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   '@npmcli/metavuln-calculator@7.1.1':
-    resolution:
-      {
-        integrity: sha512-Nkxf96V0lAx3HCpVda7Vw4P23RILgdi/5K1fmj2tZkWIYLpXAN8k2UVVOsW16TsS5F8Ws2I7Cm+PU1/rsVF47g==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-Nkxf96V0lAx3HCpVda7Vw4P23RILgdi/5K1fmj2tZkWIYLpXAN8k2UVVOsW16TsS5F8Ws2I7Cm+PU1/rsVF47g==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@npmcli/name-from-folder@2.0.0':
-    resolution:
-      {
-        integrity: sha512-pwK+BfEBZJbKdNYpHHRTNBwBoqrN/iIMO0AiGvYsp3Hoaq0WbgGSWQR6SCldZovoDpY3yje5lkFUe6gsDgJ2vg==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-pwK+BfEBZJbKdNYpHHRTNBwBoqrN/iIMO0AiGvYsp3Hoaq0WbgGSWQR6SCldZovoDpY3yje5lkFUe6gsDgJ2vg==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   '@npmcli/node-gyp@3.0.0':
-    resolution:
-      {
-        integrity: sha512-gp8pRXC2oOxu0DUE1/M3bYtb1b3/DbJ5aM113+XJBgfXdussRAsX0YOrOhdd8WvnAR6auDBvJomGAkLKA5ydxA==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-gp8pRXC2oOxu0DUE1/M3bYtb1b3/DbJ5aM113+XJBgfXdussRAsX0YOrOhdd8WvnAR6auDBvJomGAkLKA5ydxA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   '@npmcli/package-json@5.2.0':
-    resolution:
-      {
-        integrity: sha512-qe/kiqqkW0AGtvBjL8TJKZk/eBBSpnJkUWvHdQ9jM2lKHXRYYJuyNpJPlJw3c8QjC2ow6NZYiLExhUaeJelbxQ==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-qe/kiqqkW0AGtvBjL8TJKZk/eBBSpnJkUWvHdQ9jM2lKHXRYYJuyNpJPlJw3c8QjC2ow6NZYiLExhUaeJelbxQ==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@npmcli/promise-spawn@7.0.2':
-    resolution:
-      {
-        integrity: sha512-xhfYPXoV5Dy4UkY0D+v2KkwvnDfiA/8Mt3sWCGI/hM03NsYIH8ZaG6QzS9x7pje5vHZBZJ2v6VRFVTWACnqcmQ==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-xhfYPXoV5Dy4UkY0D+v2KkwvnDfiA/8Mt3sWCGI/hM03NsYIH8ZaG6QzS9x7pje5vHZBZJ2v6VRFVTWACnqcmQ==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@npmcli/query@3.1.0':
-    resolution:
-      {
-        integrity: sha512-C/iR0tk7KSKGldibYIB9x8GtO/0Bd0I2mhOaDb8ucQL/bQVTmGoeREaFj64Z5+iCBRf3dQfed0CjJL7I8iTkiQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-C/iR0tk7KSKGldibYIB9x8GtO/0Bd0I2mhOaDb8ucQL/bQVTmGoeREaFj64Z5+iCBRf3dQfed0CjJL7I8iTkiQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   '@npmcli/redact@2.0.1':
-    resolution:
-      {
-        integrity: sha512-YgsR5jCQZhVmTJvjduTOIHph0L73pK8xwMVaDY0PatySqVM9AZj93jpoXYSJqfHFxFkN9dmqTw6OiqExsS3LPw==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-YgsR5jCQZhVmTJvjduTOIHph0L73pK8xwMVaDY0PatySqVM9AZj93jpoXYSJqfHFxFkN9dmqTw6OiqExsS3LPw==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@npmcli/run-script@8.1.0':
-    resolution:
-      {
-        integrity: sha512-y7efHHwghQfk28G2z3tlZ67pLG0XdfYbcVG26r7YIXALRsrVQcTq4/tdenSmdOrEsNahIYA/eh8aEVROWGFUDg==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-y7efHHwghQfk28G2z3tlZ67pLG0XdfYbcVG26r7YIXALRsrVQcTq4/tdenSmdOrEsNahIYA/eh8aEVROWGFUDg==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@nx/devkit@20.8.3':
-    resolution:
-      {
-        integrity: sha512-5lbfJ6ICFOiGeirldQOU5fQ/W/VQ8L3dfWnmHG4UgpWSLoK/YFdRf4lTB4rS0aDXsBL0gyWABz3sZGLPGNYnPA==,
-      }
+    resolution: {integrity: sha512-5lbfJ6ICFOiGeirldQOU5fQ/W/VQ8L3dfWnmHG4UgpWSLoK/YFdRf4lTB4rS0aDXsBL0gyWABz3sZGLPGNYnPA==}
     peerDependencies:
       nx: '>= 19 <= 21'
 
   '@nx/nx-darwin-arm64@20.8.3':
-    resolution:
-      {
-        integrity: sha512-BeYnPAcnaerg6q+qR0bAb0nebwwrsvm4STSVqqVlaqLmmQpU3Bfpx44CEa5d6T9b0V11ZqVE/bkmRhMqhUcrhw==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-BeYnPAcnaerg6q+qR0bAb0nebwwrsvm4STSVqqVlaqLmmQpU3Bfpx44CEa5d6T9b0V11ZqVE/bkmRhMqhUcrhw==}
+    engines: {node: '>= 10'}
     cpu: [arm64]
     os: [darwin]
 
   '@nx/nx-darwin-x64@20.8.3':
-    resolution:
-      {
-        integrity: sha512-RIFg1VkQ4jhI+ErqEZuIeGBcJGD8t+u9J5CdQBDIASd8QRhtudBkiYLYCJb+qaQly09G7nVfxuyItlS2uRW3qA==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-RIFg1VkQ4jhI+ErqEZuIeGBcJGD8t+u9J5CdQBDIASd8QRhtudBkiYLYCJb+qaQly09G7nVfxuyItlS2uRW3qA==}
+    engines: {node: '>= 10'}
     cpu: [x64]
     os: [darwin]
 
   '@nx/nx-freebsd-x64@20.8.3':
-    resolution:
-      {
-        integrity: sha512-boQTgMUdnqpZhHMrV/xgnp/dTg5dfxw8I4d16NBwmW4j+Sez7zi/dydgsJpfZsj8TicOHvPu6KK4W5wzp82NPw==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-boQTgMUdnqpZhHMrV/xgnp/dTg5dfxw8I4d16NBwmW4j+Sez7zi/dydgsJpfZsj8TicOHvPu6KK4W5wzp82NPw==}
+    engines: {node: '>= 10'}
     cpu: [x64]
     os: [freebsd]
 
   '@nx/nx-linux-arm-gnueabihf@20.8.3':
-    resolution:
-      {
-        integrity: sha512-wpiNyY1igx1rLN3EsTLum2lDtblFijdBZB9/9u/6UDub4z9CaQ4yaC4h9n5v7yFYILwfL44YTsQKzrE+iv0y1Q==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-wpiNyY1igx1rLN3EsTLum2lDtblFijdBZB9/9u/6UDub4z9CaQ4yaC4h9n5v7yFYILwfL44YTsQKzrE+iv0y1Q==}
+    engines: {node: '>= 10'}
     cpu: [arm]
     os: [linux]
 
   '@nx/nx-linux-arm64-gnu@20.8.3':
-    resolution:
-      {
-        integrity: sha512-nbi/eZtJfWxuDwdUCiP+VJolFubtrz6XxVtB26eMAkODnREOKELHZtMOrlm8JBZCdtWCvTqibq9Az74XsqSfdA==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-nbi/eZtJfWxuDwdUCiP+VJolFubtrz6XxVtB26eMAkODnREOKELHZtMOrlm8JBZCdtWCvTqibq9Az74XsqSfdA==}
+    engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@nx/nx-linux-arm64-musl@20.8.3':
-    resolution:
-      {
-        integrity: sha512-LTTGzI8YVPlF1v0YlVf+exM+1q7rpsiUbjTTHJcfHFRU5t4BsiZD54K19Y1UBg1XFx5cwhEaIomSmJ88RwPPVQ==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-LTTGzI8YVPlF1v0YlVf+exM+1q7rpsiUbjTTHJcfHFRU5t4BsiZD54K19Y1UBg1XFx5cwhEaIomSmJ88RwPPVQ==}
+    engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@nx/nx-linux-x64-gnu@20.8.3':
-    resolution:
-      {
-        integrity: sha512-SlA4GtXvQbSzSIWLgiIiLBOjdINPOUR/im+TUbaEMZ8wiGrOY8cnk0PVt95TIQJVBeXBCeb5HnoY0lHJpMOODg==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-SlA4GtXvQbSzSIWLgiIiLBOjdINPOUR/im+TUbaEMZ8wiGrOY8cnk0PVt95TIQJVBeXBCeb5HnoY0lHJpMOODg==}
+    engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@nx/nx-linux-x64-musl@20.8.3':
-    resolution:
-      {
-        integrity: sha512-MNzkEwPktp5SQH9dJDH2wP9hgG9LsBDhKJXJfKw6sUI/6qz5+/aAjFziKy+zBnhU4AO1yXt5qEWzR8lDcIriVQ==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-MNzkEwPktp5SQH9dJDH2wP9hgG9LsBDhKJXJfKw6sUI/6qz5+/aAjFziKy+zBnhU4AO1yXt5qEWzR8lDcIriVQ==}
+    engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@nx/nx-win32-arm64-msvc@20.8.3':
-    resolution:
-      {
-        integrity: sha512-qUV7CyXKwRCM/lkvyS6Xa1MqgAuK5da6w27RAehh7LATBUKn1I4/M7DGn6L7ERCxpZuh1TrDz9pUzEy0R+Ekkg==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-qUV7CyXKwRCM/lkvyS6Xa1MqgAuK5da6w27RAehh7LATBUKn1I4/M7DGn6L7ERCxpZuh1TrDz9pUzEy0R+Ekkg==}
+    engines: {node: '>= 10'}
     cpu: [arm64]
     os: [win32]
 
   '@nx/nx-win32-x64-msvc@20.8.3':
-    resolution:
-      {
-        integrity: sha512-gX1G8u6W6EPX6PO/wv07+B++UHyCHBXyVWXITA3Kv6HoSajOxIa2Kk1rv1iDQGmX1WWxBaj3bUyYJAFBDITe4w==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-gX1G8u6W6EPX6PO/wv07+B++UHyCHBXyVWXITA3Kv6HoSajOxIa2Kk1rv1iDQGmX1WWxBaj3bUyYJAFBDITe4w==}
+    engines: {node: '>= 10'}
     cpu: [x64]
     os: [win32]
 
   '@octokit/auth-token@4.0.0':
-    resolution:
-      {
-        integrity: sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA==}
+    engines: {node: '>= 18'}
 
   '@octokit/core@5.2.2':
-    resolution:
-      {
-        integrity: sha512-/g2d4sW9nUDJOMz3mabVQvOGhVa4e/BN/Um7yca9Bb2XTzPPnfTWHWQg+IsEYO7M3Vx+EXvaM/I2pJWIMun1bg==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-/g2d4sW9nUDJOMz3mabVQvOGhVa4e/BN/Um7yca9Bb2XTzPPnfTWHWQg+IsEYO7M3Vx+EXvaM/I2pJWIMun1bg==}
+    engines: {node: '>= 18'}
 
   '@octokit/endpoint@9.0.6':
-    resolution:
-      {
-        integrity: sha512-H1fNTMA57HbkFESSt3Y9+FBICv+0jFceJFPWDePYlR/iMGrwM5ph+Dd4XRQs+8X+PUFURLQgX9ChPfhJ/1uNQw==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-H1fNTMA57HbkFESSt3Y9+FBICv+0jFceJFPWDePYlR/iMGrwM5ph+Dd4XRQs+8X+PUFURLQgX9ChPfhJ/1uNQw==}
+    engines: {node: '>= 18'}
 
   '@octokit/graphql@7.1.1':
-    resolution:
-      {
-        integrity: sha512-3mkDltSfcDUoa176nlGoA32RGjeWjl3K7F/BwHwRMJUW/IteSa4bnSV8p2ThNkcIcZU2umkZWxwETSSCJf2Q7g==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-3mkDltSfcDUoa176nlGoA32RGjeWjl3K7F/BwHwRMJUW/IteSa4bnSV8p2ThNkcIcZU2umkZWxwETSSCJf2Q7g==}
+    engines: {node: '>= 18'}
 
   '@octokit/openapi-types@24.2.0':
-    resolution:
-      {
-        integrity: sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg==,
-      }
+    resolution: {integrity: sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg==}
 
   '@octokit/plugin-enterprise-rest@6.0.1':
-    resolution:
-      {
-        integrity: sha512-93uGjlhUD+iNg1iWhUENAtJata6w5nE+V4urXOAlIXdco6xNZtUSfYY8dzp3Udy74aqO/B5UZL80x/YMa5PKRw==,
-      }
+    resolution: {integrity: sha512-93uGjlhUD+iNg1iWhUENAtJata6w5nE+V4urXOAlIXdco6xNZtUSfYY8dzp3Udy74aqO/B5UZL80x/YMa5PKRw==}
 
   '@octokit/plugin-paginate-rest@11.4.4-cjs.2':
-    resolution:
-      {
-        integrity: sha512-2dK6z8fhs8lla5PaOTgqfCGBxgAv/le+EhPs27KklPhm1bKObpu6lXzwfUEQ16ajXzqNrKMujsFyo9K2eaoISw==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-2dK6z8fhs8lla5PaOTgqfCGBxgAv/le+EhPs27KklPhm1bKObpu6lXzwfUEQ16ajXzqNrKMujsFyo9K2eaoISw==}
+    engines: {node: '>= 18'}
     peerDependencies:
       '@octokit/core': '5'
 
   '@octokit/plugin-request-log@4.0.1':
-    resolution:
-      {
-        integrity: sha512-GihNqNpGHorUrO7Qa9JbAl0dbLnqJVrV8OXe2Zm5/Y4wFkZQDfTreBzVmiRfJVfE4mClXdihHnbpyyO9FSX4HA==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-GihNqNpGHorUrO7Qa9JbAl0dbLnqJVrV8OXe2Zm5/Y4wFkZQDfTreBzVmiRfJVfE4mClXdihHnbpyyO9FSX4HA==}
+    engines: {node: '>= 18'}
     peerDependencies:
       '@octokit/core': '5'
 
   '@octokit/plugin-rest-endpoint-methods@13.3.2-cjs.1':
-    resolution:
-      {
-        integrity: sha512-VUjIjOOvF2oELQmiFpWA1aOPdawpyaCUqcEBc/UOUnj3Xp6DJGrJ1+bjUIIDzdHjnFNO6q57ODMfdEZnoBkCwQ==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-VUjIjOOvF2oELQmiFpWA1aOPdawpyaCUqcEBc/UOUnj3Xp6DJGrJ1+bjUIIDzdHjnFNO6q57ODMfdEZnoBkCwQ==}
+    engines: {node: '>= 18'}
     peerDependencies:
       '@octokit/core': ^5
 
   '@octokit/request-error@5.1.1':
-    resolution:
-      {
-        integrity: sha512-v9iyEQJH6ZntoENr9/yXxjuezh4My67CBSu9r6Ve/05Iu5gNgnisNWOsoJHTP6k0Rr0+HQIpnH+kyammu90q/g==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-v9iyEQJH6ZntoENr9/yXxjuezh4My67CBSu9r6Ve/05Iu5gNgnisNWOsoJHTP6k0Rr0+HQIpnH+kyammu90q/g==}
+    engines: {node: '>= 18'}
 
   '@octokit/request@8.4.1':
-    resolution:
-      {
-        integrity: sha512-qnB2+SY3hkCmBxZsR/MPCybNmbJe4KAlfWErXq+rBKkQJlbjdJeS85VI9r8UqeLYLvnAenU8Q1okM/0MBsAGXw==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-qnB2+SY3hkCmBxZsR/MPCybNmbJe4KAlfWErXq+rBKkQJlbjdJeS85VI9r8UqeLYLvnAenU8Q1okM/0MBsAGXw==}
+    engines: {node: '>= 18'}
 
   '@octokit/rest@20.1.2':
-    resolution:
-      {
-        integrity: sha512-GmYiltypkHHtihFwPRxlaorG5R9VAHuk/vbszVoRTGXnAsY60wYLkh/E2XiFmdZmqrisw+9FaazS1i5SbdWYgA==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-GmYiltypkHHtihFwPRxlaorG5R9VAHuk/vbszVoRTGXnAsY60wYLkh/E2XiFmdZmqrisw+9FaazS1i5SbdWYgA==}
+    engines: {node: '>= 18'}
 
   '@octokit/types@13.10.0':
-    resolution:
-      {
-        integrity: sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA==,
-      }
+    resolution: {integrity: sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA==}
 
   '@one-ini/wasm@0.1.1':
-    resolution:
-      {
-        integrity: sha512-XuySG1E38YScSJoMlqovLru4KTUNSjgVTIjyh7qMX6aNN5HY5Ct5LhRJdxO79JtTzKfzV/bnWpz+zquYrISsvw==,
-      }
+    resolution: {integrity: sha512-XuySG1E38YScSJoMlqovLru4KTUNSjgVTIjyh7qMX6aNN5HY5Ct5LhRJdxO79JtTzKfzV/bnWpz+zquYrISsvw==}
 
   '@oxfmt/binding-android-arm-eabi@0.51.0':
-    resolution:
-      {
-        integrity: sha512-Ni0sCqg5CIHaLIYFGj+ncbcumylvNC6FE4rfD0KfdmnWHbPJ+zev0qZCXKxy2hFVa0fYRK0yPzf5nzPbkZou7g==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-Ni0sCqg5CIHaLIYFGj+ncbcumylvNC6FE4rfD0KfdmnWHbPJ+zev0qZCXKxy2hFVa0fYRK0yPzf5nzPbkZou7g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [android]
 
   '@oxfmt/binding-android-arm64@0.51.0':
-    resolution:
-      {
-        integrity: sha512-eu5lAZjuo0KAkp+M24EhDqfOwA8owQ8d7wyBlOUUGRbDLHpU3IRlDHp8Dif+YqGlxs6jra7yS6WQu/NkPhAxeg==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-eu5lAZjuo0KAkp+M24EhDqfOwA8owQ8d7wyBlOUUGRbDLHpU3IRlDHp8Dif+YqGlxs6jra7yS6WQu/NkPhAxeg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [android]
 
   '@oxfmt/binding-darwin-arm64@0.51.0':
-    resolution:
-      {
-        integrity: sha512-6LsUNIdURhhcIfIn8+xsOb61mSTa9msAHTeSGx9Jf4rsP/gN8PGCF+SKWPAQZbND2w/WBkqQ6303jqEEIXzMdQ==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-6LsUNIdURhhcIfIn8+xsOb61mSTa9msAHTeSGx9Jf4rsP/gN8PGCF+SKWPAQZbND2w/WBkqQ6303jqEEIXzMdQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [darwin]
 
   '@oxfmt/binding-darwin-x64@0.51.0':
-    resolution:
-      {
-        integrity: sha512-9aUMGmVxdHjYMsEAW1tNRoieTJXlVNDFkRvIR1J7LttJXWjVYCu2ekclLij2KJtxBxSQOYSHd12ME/adVGVbZg==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-9aUMGmVxdHjYMsEAW1tNRoieTJXlVNDFkRvIR1J7LttJXWjVYCu2ekclLij2KJtxBxSQOYSHd12ME/adVGVbZg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [darwin]
 
   '@oxfmt/binding-freebsd-x64@0.51.0':
-    resolution:
-      {
-        integrity: sha512-mkY1nhZTqYb+NHaAWxOCKISN6FwdrwMNsu17vTUA3wzUV2VJ+Paq15ZokRcsMU/2PUdHO73prxyeJpjXQ3MPpQ==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-mkY1nhZTqYb+NHaAWxOCKISN6FwdrwMNsu17vTUA3wzUV2VJ+Paq15ZokRcsMU/2PUdHO73prxyeJpjXQ3MPpQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [freebsd]
 
   '@oxfmt/binding-linux-arm-gnueabihf@0.51.0':
-    resolution:
-      {
-        integrity: sha512-wtFwNwE4+YCNuPaWoGDZeGsKvD6D1YSUNBJNn/rJBh7CrDBThFE+TBI5kY7vRW9rIOQRsbW2IpyyL3Du4Zqwiw==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-wtFwNwE4+YCNuPaWoGDZeGsKvD6D1YSUNBJNn/rJBh7CrDBThFE+TBI5kY7vRW9rIOQRsbW2IpyyL3Du4Zqwiw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
   '@oxfmt/binding-linux-arm-musleabihf@0.51.0':
-    resolution:
-      {
-        integrity: sha512-rnOaNx86G7iRKM6lsCIQMux0SMGNC/TEbFR+r7lpruJ12bnrIWgxd5w1PLqOvgR9r8ZJbpK/zfRKctJnh8/Jfg==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-rnOaNx86G7iRKM6lsCIQMux0SMGNC/TEbFR+r7lpruJ12bnrIWgxd5w1PLqOvgR9r8ZJbpK/zfRKctJnh8/Jfg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm]
     os: [linux]
 
   '@oxfmt/binding-linux-arm64-gnu@0.51.0':
-    resolution:
-      {
-        integrity: sha512-jOgDzSqWcICGRjsp4mc08FxKMN8vzP2Kgs4E0d2HUP99F+nJDQKklRV4Zuj+0gcBgjrzx2CbpqaIdUVPepCojA==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-jOgDzSqWcICGRjsp4mc08FxKMN8vzP2Kgs4E0d2HUP99F+nJDQKklRV4Zuj+0gcBgjrzx2CbpqaIdUVPepCojA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@oxfmt/binding-linux-arm64-musl@0.51.0':
-    resolution:
-      {
-        integrity: sha512-KBUCdrH5bwVrAvI9gU/1S55oH6fzXjr++J/oVocdu7bYTks1l7DNNT+rLd/1TDdAEjObGwmfWamn7LC1m8A0DQ==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-KBUCdrH5bwVrAvI9gU/1S55oH6fzXjr++J/oVocdu7bYTks1l7DNNT+rLd/1TDdAEjObGwmfWamn7LC1m8A0DQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@oxfmt/binding-linux-ppc64-gnu@0.51.0':
-    resolution:
-      {
-        integrity: sha512-NapfjYsABFqTJ1Dn9Efq6sN5esaHconVKwVLbDGNQLrwpOx/g17mkwErHzU72PutL67nf3wNAkbq122H+zLxag==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-NapfjYsABFqTJ1Dn9Efq6sN5esaHconVKwVLbDGNQLrwpOx/g17mkwErHzU72PutL67nf3wNAkbq122H+zLxag==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@oxfmt/binding-linux-riscv64-gnu@0.51.0':
-    resolution:
-      {
-        integrity: sha512-5dlDt1dUZCVi6elIhiK1PWg9wpTzTcIuj0IZnSurvIoMrhOWqqTcc1dSTxcSkNaBZhfsNqRZdINI1zAgbKkJNQ==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-5dlDt1dUZCVi6elIhiK1PWg9wpTzTcIuj0IZnSurvIoMrhOWqqTcc1dSTxcSkNaBZhfsNqRZdINI1zAgbKkJNQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@oxfmt/binding-linux-riscv64-musl@0.51.0':
-    resolution:
-      {
-        integrity: sha512-pgdWUJn0S5nulyiVdlFV8DzCUnGXkU99W5PSkkmbaZW+LrZBPxpezun4G0DDHbQaVYuJeCuKsXsGKGo77CkUTQ==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-pgdWUJn0S5nulyiVdlFV8DzCUnGXkU99W5PSkkmbaZW+LrZBPxpezun4G0DDHbQaVYuJeCuKsXsGKGo77CkUTQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@oxfmt/binding-linux-s390x-gnu@0.51.0':
-    resolution:
-      {
-        integrity: sha512-2XTFUe97CbDGAI8vjwDfZ1HdakO0XIADyJ24idEg64SC4/K4in/OisXVnrW4NMK7I6TgC7EqRhC0Ln/nKhAemA==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-2XTFUe97CbDGAI8vjwDfZ1HdakO0XIADyJ24idEg64SC4/K4in/OisXVnrW4NMK7I6TgC7EqRhC0Ln/nKhAemA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@oxfmt/binding-linux-x64-gnu@0.51.0':
-    resolution:
-      {
-        integrity: sha512-kQ1OuCqqt/yyf0ZN9VFxW1/JnlgJgii3Dr7pWf9vNBvrX1hv6g39/+mc5oGRHRGJFZtl3zsGDWR9c5N2B/gwBw==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-kQ1OuCqqt/yyf0ZN9VFxW1/JnlgJgii3Dr7pWf9vNBvrX1hv6g39/+mc5oGRHRGJFZtl3zsGDWR9c5N2B/gwBw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@oxfmt/binding-linux-x64-musl@0.51.0':
-    resolution:
-      {
-        integrity: sha512-ARTYqxHF475o96Gbn41hvSWSSRygPlRDXZZgZ9I2scU1y0qiWpCQyZCoefaQa0mwv+wwtZ+luS4YOzsRzM/izg==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-ARTYqxHF475o96Gbn41hvSWSSRygPlRDXZZgZ9I2scU1y0qiWpCQyZCoefaQa0mwv+wwtZ+luS4YOzsRzM/izg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@oxfmt/binding-openharmony-arm64@0.51.0':
-    resolution:
-      {
-        integrity: sha512-QiC1XrCl6a6BmqMzduO8hdIRMf1m44hCkt2Q68KWkTvUB/E7fd2iomyNh6KnnRca5w6eBrRAAtLFqTh+xjsjJA==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-QiC1XrCl6a6BmqMzduO8hdIRMf1m44hCkt2Q68KWkTvUB/E7fd2iomyNh6KnnRca5w6eBrRAAtLFqTh+xjsjJA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [openharmony]
 
   '@oxfmt/binding-win32-arm64-msvc@0.51.0':
-    resolution:
-      {
-        integrity: sha512-NC/hJb9dtU23Zf8L7IVK95xnFjiQ7AfcLO2l5pb69TDEr958qxrtnB2CveeeNSCBFNIkgaTCfd/vHNSoG78l9g==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-NC/hJb9dtU23Zf8L7IVK95xnFjiQ7AfcLO2l5pb69TDEr958qxrtnB2CveeeNSCBFNIkgaTCfd/vHNSoG78l9g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [arm64]
     os: [win32]
 
   '@oxfmt/binding-win32-ia32-msvc@0.51.0':
-    resolution:
-      {
-        integrity: sha512-2C45za4Rj36n8YIbhRL1PQbxmXJYf81WEcAgvj5I4ptRROG+A+81hREEN5bmCHADE1UfYaN312U6tkILoZZy6w==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-2C45za4Rj36n8YIbhRL1PQbxmXJYf81WEcAgvj5I4ptRROG+A+81hREEN5bmCHADE1UfYaN312U6tkILoZZy6w==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [ia32]
     os: [win32]
 
   '@oxfmt/binding-win32-x64-msvc@0.51.0':
-    resolution:
-      {
-        integrity: sha512-73RqdAuVKQTkjZIDw08JaDHUM4lav5Qu+CaPwg4QbbA7k8o7LEW0p3UsfZ/F8dsO/pwVYh3RzFcanwLRTTahbQ==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-73RqdAuVKQTkjZIDw08JaDHUM4lav5Qu+CaPwg4QbbA7k8o7LEW0p3UsfZ/F8dsO/pwVYh3RzFcanwLRTTahbQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     cpu: [x64]
     os: [win32]
 
   '@paralleldrive/cuid2@2.3.1':
-    resolution:
-      {
-        integrity: sha512-XO7cAxhnTZl0Yggq6jOgjiOHhbgcO4NqFqwSmQpjK3b6TEE6Uj/jfSk6wzYyemh3+I0sHirKSetjQwn5cZktFw==,
-      }
+    resolution: {integrity: sha512-XO7cAxhnTZl0Yggq6jOgjiOHhbgcO4NqFqwSmQpjK3b6TEE6Uj/jfSk6wzYyemh3+I0sHirKSetjQwn5cZktFw==}
 
   '@pgpm/database-jobs@0.18.0':
-    resolution:
-      {
-        integrity: sha512-3LX7ZQJQEMHd4POG2I2xPzMFR2X6LwvuxJAMpLhcc/I4P3EbEyEig6rPpsyDr9uabRjgUWfZDz05w6cW8X4KwA==,
-      }
+    resolution: {integrity: sha512-3LX7ZQJQEMHd4POG2I2xPzMFR2X6LwvuxJAMpLhcc/I4P3EbEyEig6rPpsyDr9uabRjgUWfZDz05w6cW8X4KwA==}
 
   '@pgpm/database-jobs@0.21.0':
-    resolution:
-      {
-        integrity: sha512-TN6Uddyq5PJMQ7P+dJOCl0xwyIW1Hv8PkJmRshMNljzt0OVu4Mq8YR5gNkTDveGGHdYCDyP0vhCrpty9aQld6g==,
-      }
+    resolution: {integrity: sha512-TN6Uddyq5PJMQ7P+dJOCl0xwyIW1Hv8PkJmRshMNljzt0OVu4Mq8YR5gNkTDveGGHdYCDyP0vhCrpty9aQld6g==}
 
   '@pgpm/inflection@0.18.0':
-    resolution:
-      {
-        integrity: sha512-gHfxI6l/+cE9zY5ea6BjVjNcb9VKIavqRXGVyw16Fy0n4HgCmxF8ccZFFPq46JXfakNSk3cPTHDYvvWQaAlIPA==,
-      }
+    resolution: {integrity: sha512-gHfxI6l/+cE9zY5ea6BjVjNcb9VKIavqRXGVyw16Fy0n4HgCmxF8ccZFFPq46JXfakNSk3cPTHDYvvWQaAlIPA==}
 
   '@pgpm/inflection@0.21.0':
-    resolution:
-      {
-        integrity: sha512-tb1OQCQp1i5SjT04CCN27ptGQcDXidVZrDB8SJsdZZrz6Rcl0WStf4t50z5CSUebg8RJxkpiF4VNpv583RCuhQ==,
-      }
+    resolution: {integrity: sha512-tb1OQCQp1i5SjT04CCN27ptGQcDXidVZrDB8SJsdZZrz6Rcl0WStf4t50z5CSUebg8RJxkpiF4VNpv583RCuhQ==}
 
   '@pgpm/metaschema-modules@0.21.1':
-    resolution:
-      {
-        integrity: sha512-6RTHN+PcxmTma7k7uHPZdjtN92P3kkqndXxu2acuSOpXi1sxrN5nNSNgi2r42ovl92B8MKy4r7SyF5DUlQwD1A==,
-      }
+    resolution: {integrity: sha512-6RTHN+PcxmTma7k7uHPZdjtN92P3kkqndXxu2acuSOpXi1sxrN5nNSNgi2r42ovl92B8MKy4r7SyF5DUlQwD1A==}
 
   '@pgpm/metaschema-schema@0.18.0':
-    resolution:
-      {
-        integrity: sha512-joIBoYegI4ZQFFPW7w0HhNXMT+sXnmSytX8YBxGgi5XZqjE2aQdtZcWBIiwZa3MjqU7mYN2xlZt5gPmo/IzLMw==,
-      }
+    resolution: {integrity: sha512-joIBoYegI4ZQFFPW7w0HhNXMT+sXnmSytX8YBxGgi5XZqjE2aQdtZcWBIiwZa3MjqU7mYN2xlZt5gPmo/IzLMw==}
 
   '@pgpm/metaschema-schema@0.21.0':
-    resolution:
-      {
-        integrity: sha512-kRfVyysGOrGcZEElcAJWaX9Xx2f5fMPtI4rmAxI11vJ0axYUcqtI+9fyp7McwqXnIHr0ShR28jvwqUGaZherJw==,
-      }
+    resolution: {integrity: sha512-kRfVyysGOrGcZEElcAJWaX9Xx2f5fMPtI4rmAxI11vJ0axYUcqtI+9fyp7McwqXnIHr0ShR28jvwqUGaZherJw==}
 
   '@pgpm/services@0.18.0':
-    resolution:
-      {
-        integrity: sha512-YedLEVdgwkHden55uaZaO8O3HACEiIvblYmPFsQk1ivHwzw1l0KUv6WT5+idwMC/SOsexH/Xq8ckSSM84ErWtQ==,
-      }
+    resolution: {integrity: sha512-YedLEVdgwkHden55uaZaO8O3HACEiIvblYmPFsQk1ivHwzw1l0KUv6WT5+idwMC/SOsexH/Xq8ckSSM84ErWtQ==}
 
   '@pgpm/types@0.18.0':
-    resolution:
-      {
-        integrity: sha512-w6pfcS5HuJ2IGfyn74mGChl0nhNBIbxdu6sarlARGveZFHvBkTIPKEezA524sLKhUHda84YWuExEhCUd6N/AqQ==,
-      }
+    resolution: {integrity: sha512-w6pfcS5HuJ2IGfyn74mGChl0nhNBIbxdu6sarlARGveZFHvBkTIPKEezA524sLKhUHda84YWuExEhCUd6N/AqQ==}
 
   '@pgpm/types@0.21.0':
-    resolution:
-      {
-        integrity: sha512-F5ph4z7JWwKVcy/CmAgodEIXqXCwSgv0ESVxIV2spdl01RgNi0SdKuHqVJnjp8rbHHUtlCPRj/UlAopUSpIIOg==,
-      }
+    resolution: {integrity: sha512-F5ph4z7JWwKVcy/CmAgodEIXqXCwSgv0ESVxIV2spdl01RgNi0SdKuHqVJnjp8rbHHUtlCPRj/UlAopUSpIIOg==}
 
   '@pgpm/verify@0.18.0':
-    resolution:
-      {
-        integrity: sha512-7XtY+hj9CbYb0ZhD0LJRp+TErtYS2z0FZbdkMNM7UabEwz05VLlS/lXbdtn5hksbUq6dkIxwxQ2mfFpATPpqDQ==,
-      }
+    resolution: {integrity: sha512-7XtY+hj9CbYb0ZhD0LJRp+TErtYS2z0FZbdkMNM7UabEwz05VLlS/lXbdtn5hksbUq6dkIxwxQ2mfFpATPpqDQ==}
 
   '@pgpm/verify@0.21.0':
-    resolution:
-      {
-        integrity: sha512-z4iiwEUrUR+aIvxfu4+HefitVPLtypXdbyEkbNJ//EMsnzturo6wzxT1e60w/Xp29AzF6m5OaJ0djc6lzr9hTw==,
-      }
+    resolution: {integrity: sha512-z4iiwEUrUR+aIvxfu4+HefitVPLtypXdbyEkbNJ//EMsnzturo6wzxT1e60w/Xp29AzF6m5OaJ0djc6lzr9hTw==}
 
   '@pgsql/quotes@17.1.0':
-    resolution:
-      {
-        integrity: sha512-J/H+LcrENBpYgL45WW6aTjb5Yk4tX4+AmB2/k8KZa+Zh3wiCtqmNIag+HZz5HmWaF6EZK9ZGC95NBD1fs+rUvg==,
-      }
+    resolution: {integrity: sha512-J/H+LcrENBpYgL45WW6aTjb5Yk4tX4+AmB2/k8KZa+Zh3wiCtqmNIag+HZz5HmWaF6EZK9ZGC95NBD1fs+rUvg==}
 
   '@pgsql/traverse@17.2.6':
-    resolution:
-      {
-        integrity: sha512-BLOE9DUcvd3y3Ogf56mmpTONPylnMuFCo9PvHQA9SXavcRPhRtvIZ/sRO2ja+bUWK/3KTLJ1Hb61CbbdPkcHoA==,
-      }
+    resolution: {integrity: sha512-BLOE9DUcvd3y3Ogf56mmpTONPylnMuFCo9PvHQA9SXavcRPhRtvIZ/sRO2ja+bUWK/3KTLJ1Hb61CbbdPkcHoA==}
 
   '@pgsql/types@17.6.2':
-    resolution:
-      {
-        integrity: sha512-1UtbELdbqNdyOShhrVfSz3a1gDi0s9XXiQemx+6QqtsrXe62a6zOGU+vjb2GRfG5jeEokI1zBBcfD42enRv0Rw==,
-      }
+    resolution: {integrity: sha512-1UtbELdbqNdyOShhrVfSz3a1gDi0s9XXiQemx+6QqtsrXe62a6zOGU+vjb2GRfG5jeEokI1zBBcfD42enRv0Rw==}
 
   '@pgsql/utils@17.8.17':
-    resolution:
-      {
-        integrity: sha512-JAbRaKBdH0c6GbSgiepwdsis9AG9Kgz9sdmL5e+iBYFZRsFBGKoe1jnxJ0tAMjWYcLus2qeDN6gqQaPYtx1EOg==,
-      }
+    resolution: {integrity: sha512-JAbRaKBdH0c6GbSgiepwdsis9AG9Kgz9sdmL5e+iBYFZRsFBGKoe1jnxJ0tAMjWYcLus2qeDN6gqQaPYtx1EOg==}
 
   '@pkgjs/parseargs@0.11.0':
-    resolution:
-      {
-        integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
+    engines: {node: '>=14'}
 
   '@pkgr/core@0.2.9':
-    resolution:
-      {
-        integrity: sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==,
-      }
-    engines: { node: ^12.20.0 || ^14.18.0 || >=16.0.0 }
+    resolution: {integrity: sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
 
   '@playwright/test@1.60.0':
-    resolution:
-      {
-        integrity: sha512-O71yZIbAh/PxDMNGns37GHBIfrVkEVyn+AXyIa5dOTfb4/xNvRWV+Vv/NMbNCtODB/pO7vLlF2OTmMVLhmr7Ag==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-O71yZIbAh/PxDMNGns37GHBIfrVkEVyn+AXyIa5dOTfb4/xNvRWV+Vv/NMbNCtODB/pO7vLlF2OTmMVLhmr7Ag==}
+    engines: {node: '>=18'}
     hasBin: true
 
   '@protobufjs/aspromise@1.1.2':
-    resolution:
-      {
-        integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==,
-      }
+    resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==}
 
   '@protobufjs/base64@1.1.2':
-    resolution:
-      {
-        integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==,
-      }
+    resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==}
 
   '@protobufjs/codegen@2.0.5':
-    resolution:
-      {
-        integrity: sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==,
-      }
+    resolution: {integrity: sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==}
 
   '@protobufjs/eventemitter@1.1.0':
-    resolution:
-      {
-        integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==,
-      }
+    resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==}
 
   '@protobufjs/fetch@1.1.0':
-    resolution:
-      {
-        integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==,
-      }
+    resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==}
 
   '@protobufjs/float@1.0.2':
-    resolution:
-      {
-        integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==,
-      }
+    resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==}
 
   '@protobufjs/inquire@1.1.1':
-    resolution:
-      {
-        integrity: sha512-mnzgDV26ueAvk7rsbt9L7bE0SuAoqyuys/sMMrmVcN5x9VsxpcG3rqAUSgDyLp0UZlmNfIbQ4fHfCtreVBk8Ew==,
-      }
+    resolution: {integrity: sha512-mnzgDV26ueAvk7rsbt9L7bE0SuAoqyuys/sMMrmVcN5x9VsxpcG3rqAUSgDyLp0UZlmNfIbQ4fHfCtreVBk8Ew==}
 
   '@protobufjs/path@1.1.2':
-    resolution:
-      {
-        integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==,
-      }
+    resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==}
 
   '@protobufjs/pool@1.1.0':
-    resolution:
-      {
-        integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==,
-      }
+    resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==}
 
   '@protobufjs/utf8@1.1.1':
-    resolution:
-      {
-        integrity: sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==,
-      }
+    resolution: {integrity: sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==}
 
   '@radix-ui/primitive@1.1.3':
-    resolution:
-      {
-        integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==,
-      }
+    resolution: {integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==}
 
   '@radix-ui/react-arrow@1.1.7':
-    resolution:
-      {
-        integrity: sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==,
-      }
+    resolution: {integrity: sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6082,10 +5159,7 @@ packages:
         optional: true
 
   '@radix-ui/react-collection@1.1.7':
-    resolution:
-      {
-        integrity: sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==,
-      }
+    resolution: {integrity: sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6098,10 +5172,7 @@ packages:
         optional: true
 
   '@radix-ui/react-compose-refs@1.1.2':
-    resolution:
-      {
-        integrity: sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==,
-      }
+    resolution: {integrity: sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6110,10 +5181,7 @@ packages:
         optional: true
 
   '@radix-ui/react-context@1.1.2':
-    resolution:
-      {
-        integrity: sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==,
-      }
+    resolution: {integrity: sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6122,10 +5190,7 @@ packages:
         optional: true
 
   '@radix-ui/react-dialog@1.1.15':
-    resolution:
-      {
-        integrity: sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==,
-      }
+    resolution: {integrity: sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6138,10 +5203,7 @@ packages:
         optional: true
 
   '@radix-ui/react-direction@1.1.1':
-    resolution:
-      {
-        integrity: sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==,
-      }
+    resolution: {integrity: sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6150,10 +5212,7 @@ packages:
         optional: true
 
   '@radix-ui/react-dismissable-layer@1.1.11':
-    resolution:
-      {
-        integrity: sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==,
-      }
+    resolution: {integrity: sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6166,10 +5225,7 @@ packages:
         optional: true
 
   '@radix-ui/react-dropdown-menu@2.1.16':
-    resolution:
-      {
-        integrity: sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==,
-      }
+    resolution: {integrity: sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6182,10 +5238,7 @@ packages:
         optional: true
 
   '@radix-ui/react-focus-guards@1.1.3':
-    resolution:
-      {
-        integrity: sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==,
-      }
+    resolution: {integrity: sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6194,10 +5247,7 @@ packages:
         optional: true
 
   '@radix-ui/react-focus-scope@1.1.7':
-    resolution:
-      {
-        integrity: sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==,
-      }
+    resolution: {integrity: sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6210,10 +5260,7 @@ packages:
         optional: true
 
   '@radix-ui/react-id@1.1.1':
-    resolution:
-      {
-        integrity: sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==,
-      }
+    resolution: {integrity: sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6222,10 +5269,7 @@ packages:
         optional: true
 
   '@radix-ui/react-menu@2.1.16':
-    resolution:
-      {
-        integrity: sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg==,
-      }
+    resolution: {integrity: sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6238,10 +5282,7 @@ packages:
         optional: true
 
   '@radix-ui/react-popper@1.2.8':
-    resolution:
-      {
-        integrity: sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==,
-      }
+    resolution: {integrity: sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6254,10 +5295,7 @@ packages:
         optional: true
 
   '@radix-ui/react-portal@1.1.9':
-    resolution:
-      {
-        integrity: sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==,
-      }
+    resolution: {integrity: sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6270,10 +5308,7 @@ packages:
         optional: true
 
   '@radix-ui/react-presence@1.1.5':
-    resolution:
-      {
-        integrity: sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==,
-      }
+    resolution: {integrity: sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6286,10 +5321,7 @@ packages:
         optional: true
 
   '@radix-ui/react-primitive@2.1.3':
-    resolution:
-      {
-        integrity: sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==,
-      }
+    resolution: {integrity: sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6302,10 +5334,7 @@ packages:
         optional: true
 
   '@radix-ui/react-primitive@2.1.4':
-    resolution:
-      {
-        integrity: sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg==,
-      }
+    resolution: {integrity: sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6318,10 +5347,7 @@ packages:
         optional: true
 
   '@radix-ui/react-roving-focus@1.1.11':
-    resolution:
-      {
-        integrity: sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==,
-      }
+    resolution: {integrity: sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6334,10 +5360,7 @@ packages:
         optional: true
 
   '@radix-ui/react-slot@1.2.3':
-    resolution:
-      {
-        integrity: sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==,
-      }
+    resolution: {integrity: sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6346,10 +5369,7 @@ packages:
         optional: true
 
   '@radix-ui/react-slot@1.2.4':
-    resolution:
-      {
-        integrity: sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA==,
-      }
+    resolution: {integrity: sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6358,10 +5378,7 @@ packages:
         optional: true
 
   '@radix-ui/react-tooltip@1.2.8':
-    resolution:
-      {
-        integrity: sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==,
-      }
+    resolution: {integrity: sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6374,10 +5391,7 @@ packages:
         optional: true
 
   '@radix-ui/react-use-callback-ref@1.1.1':
-    resolution:
-      {
-        integrity: sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==,
-      }
+    resolution: {integrity: sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6386,10 +5400,7 @@ packages:
         optional: true
 
   '@radix-ui/react-use-controllable-state@1.2.2':
-    resolution:
-      {
-        integrity: sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==,
-      }
+    resolution: {integrity: sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6398,10 +5409,7 @@ packages:
         optional: true
 
   '@radix-ui/react-use-effect-event@0.0.2':
-    resolution:
-      {
-        integrity: sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==,
-      }
+    resolution: {integrity: sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6410,10 +5418,7 @@ packages:
         optional: true
 
   '@radix-ui/react-use-escape-keydown@1.1.1':
-    resolution:
-      {
-        integrity: sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==,
-      }
+    resolution: {integrity: sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6422,10 +5427,7 @@ packages:
         optional: true
 
   '@radix-ui/react-use-layout-effect@1.1.1':
-    resolution:
-      {
-        integrity: sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==,
-      }
+    resolution: {integrity: sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6434,10 +5436,7 @@ packages:
         optional: true
 
   '@radix-ui/react-use-rect@1.1.1':
-    resolution:
-      {
-        integrity: sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==,
-      }
+    resolution: {integrity: sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6446,10 +5445,7 @@ packages:
         optional: true
 
   '@radix-ui/react-use-size@1.1.1':
-    resolution:
-      {
-        integrity: sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==,
-      }
+    resolution: {integrity: sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
@@ -6458,10 +5454,7 @@ packages:
         optional: true
 
   '@radix-ui/react-visually-hidden@1.2.3':
-    resolution:
-      {
-        integrity: sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==,
-      }
+    resolution: {integrity: sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6474,10 +5467,7 @@ packages:
         optional: true
 
   '@radix-ui/react-visually-hidden@1.2.4':
-    resolution:
-      {
-        integrity: sha512-kaeiyGCe844dkb9AVF+rb4yTyb1LiLN/e3es3nLiRyN4dC8AduBYPMnnNlDjX2VDOcvDEiPnRNMJeWCfsX0txg==,
-      }
+    resolution: {integrity: sha512-kaeiyGCe844dkb9AVF+rb4yTyb1LiLN/e3es3nLiRyN4dC8AduBYPMnnNlDjX2VDOcvDEiPnRNMJeWCfsX0txg==}
     peerDependencies:
       '@types/react': '*'
       '@types/react-dom': '*'
@@ -6490,581 +5480,354 @@ packages:
         optional: true
 
   '@radix-ui/rect@1.1.1':
-    resolution:
-      {
-        integrity: sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==,
-      }
+    resolution: {integrity: sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==}
 
   '@react-aria/focus@3.21.5':
-    resolution:
-      {
-        integrity: sha512-V18fwCyf8zqgJdpLQeDU5ZRNd9TeOfBbhLgmX77Zr5ae9XwaoJ1R3SFJG1wCJX60t34AW+aLZSEEK+saQElf3Q==,
-      }
+    resolution: {integrity: sha512-V18fwCyf8zqgJdpLQeDU5ZRNd9TeOfBbhLgmX77Zr5ae9XwaoJ1R3SFJG1wCJX60t34AW+aLZSEEK+saQElf3Q==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
       react-dom: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
 
   '@react-aria/interactions@3.27.1':
-    resolution:
-      {
-        integrity: sha512-M3wLpTTmDflI0QGNK0PJNUaBXXfeBXue8ZxLMngfc1piHNiH4G5lUvWd9W14XVbqrSCVY8i8DfGrNYpyyZu0tw==,
-      }
+    resolution: {integrity: sha512-M3wLpTTmDflI0QGNK0PJNUaBXXfeBXue8ZxLMngfc1piHNiH4G5lUvWd9W14XVbqrSCVY8i8DfGrNYpyyZu0tw==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
       react-dom: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
 
   '@react-aria/ssr@3.9.10':
-    resolution:
-      {
-        integrity: sha512-hvTm77Pf+pMBhuBm760Li0BVIO38jv1IBws1xFm1NoL26PU+fe+FMW5+VZWyANR6nYL65joaJKZqOdTQMkO9IQ==,
-      }
-    engines: { node: '>= 12' }
+    resolution: {integrity: sha512-hvTm77Pf+pMBhuBm760Li0BVIO38jv1IBws1xFm1NoL26PU+fe+FMW5+VZWyANR6nYL65joaJKZqOdTQMkO9IQ==}
+    engines: {node: '>= 12'}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
 
   '@react-aria/utils@3.33.1':
-    resolution:
-      {
-        integrity: sha512-kIx1Sj6bbAT0pdqCegHuPanR9zrLn5zMRiM7LN12rgRf55S19ptd9g3ncahArifYTRkfEU9VIn+q0HjfMqS9/w==,
-      }
+    resolution: {integrity: sha512-kIx1Sj6bbAT0pdqCegHuPanR9zrLn5zMRiM7LN12rgRf55S19ptd9g3ncahArifYTRkfEU9VIn+q0HjfMqS9/w==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
       react-dom: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
 
   '@react-stately/flags@3.1.2':
-    resolution:
-      {
-        integrity: sha512-2HjFcZx1MyQXoPqcBGALwWWmgFVUk2TuKVIQxCbRq7fPyWXIl6VHcakCLurdtYC2Iks7zizvz0Idv48MQ38DWg==,
-      }
+    resolution: {integrity: sha512-2HjFcZx1MyQXoPqcBGALwWWmgFVUk2TuKVIQxCbRq7fPyWXIl6VHcakCLurdtYC2Iks7zizvz0Idv48MQ38DWg==}
 
   '@react-stately/utils@3.11.0':
-    resolution:
-      {
-        integrity: sha512-8LZpYowJ9eZmmYLpudbo/eclIRnbhWIJZ994ncmlKlouNzKohtM8qTC6B1w1pwUbiwGdUoyzLuQbeaIor5Dvcw==,
-      }
+    resolution: {integrity: sha512-8LZpYowJ9eZmmYLpudbo/eclIRnbhWIJZ994ncmlKlouNzKohtM8qTC6B1w1pwUbiwGdUoyzLuQbeaIor5Dvcw==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
 
   '@react-types/shared@3.33.1':
-    resolution:
-      {
-        integrity: sha512-oJHtjvLG43VjwemQDadlR5g/8VepK56B/xKO2XORPHt9zlW6IZs3tZrYlvH29BMvoqC7RtE7E5UjgbnbFtDGag==,
-      }
+    resolution: {integrity: sha512-oJHtjvLG43VjwemQDadlR5g/8VepK56B/xKO2XORPHt9zlW6IZs3tZrYlvH29BMvoqC7RtE7E5UjgbnbFtDGag==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0-rc.1
 
   '@rolldown/pluginutils@1.0.0-beta.27':
-    resolution:
-      {
-        integrity: sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==,
-      }
+    resolution: {integrity: sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==}
 
   '@rollup/rollup-android-arm-eabi@4.57.1':
-    resolution:
-      {
-        integrity: sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==,
-      }
+    resolution: {integrity: sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==}
     cpu: [arm]
     os: [android]
 
   '@rollup/rollup-android-arm64@4.57.1':
-    resolution:
-      {
-        integrity: sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==,
-      }
+    resolution: {integrity: sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==}
     cpu: [arm64]
     os: [android]
 
   '@rollup/rollup-darwin-arm64@4.57.1':
-    resolution:
-      {
-        integrity: sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==,
-      }
+    resolution: {integrity: sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==}
     cpu: [arm64]
     os: [darwin]
 
   '@rollup/rollup-darwin-x64@4.57.1':
-    resolution:
-      {
-        integrity: sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==,
-      }
+    resolution: {integrity: sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==}
     cpu: [x64]
     os: [darwin]
 
   '@rollup/rollup-freebsd-arm64@4.57.1':
-    resolution:
-      {
-        integrity: sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==,
-      }
+    resolution: {integrity: sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==}
     cpu: [arm64]
     os: [freebsd]
 
   '@rollup/rollup-freebsd-x64@4.57.1':
-    resolution:
-      {
-        integrity: sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==,
-      }
+    resolution: {integrity: sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==}
     cpu: [x64]
     os: [freebsd]
 
   '@rollup/rollup-linux-arm-gnueabihf@4.57.1':
-    resolution:
-      {
-        integrity: sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==,
-      }
+    resolution: {integrity: sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==}
     cpu: [arm]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm-musleabihf@4.57.1':
-    resolution:
-      {
-        integrity: sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==,
-      }
+    resolution: {integrity: sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==}
     cpu: [arm]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-arm64-gnu@4.57.1':
-    resolution:
-      {
-        integrity: sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==,
-      }
+    resolution: {integrity: sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-arm64-musl@4.57.1':
-    resolution:
-      {
-        integrity: sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==,
-      }
+    resolution: {integrity: sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-loong64-gnu@4.57.1':
-    resolution:
-      {
-        integrity: sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==,
-      }
+    resolution: {integrity: sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==}
     cpu: [loong64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-loong64-musl@4.57.1':
-    resolution:
-      {
-        integrity: sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==,
-      }
+    resolution: {integrity: sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==}
     cpu: [loong64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-ppc64-gnu@4.57.1':
-    resolution:
-      {
-        integrity: sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==,
-      }
+    resolution: {integrity: sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-ppc64-musl@4.57.1':
-    resolution:
-      {
-        integrity: sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==,
-      }
+    resolution: {integrity: sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==}
     cpu: [ppc64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-riscv64-gnu@4.57.1':
-    resolution:
-      {
-        integrity: sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==,
-      }
+    resolution: {integrity: sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-riscv64-musl@4.57.1':
-    resolution:
-      {
-        integrity: sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==,
-      }
+    resolution: {integrity: sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-linux-s390x-gnu@4.57.1':
-    resolution:
-      {
-        integrity: sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==,
-      }
+    resolution: {integrity: sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-gnu@4.57.1':
-    resolution:
-      {
-        integrity: sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==,
-      }
+    resolution: {integrity: sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@rollup/rollup-linux-x64-musl@4.57.1':
-    resolution:
-      {
-        integrity: sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==,
-      }
+    resolution: {integrity: sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@rollup/rollup-openbsd-x64@4.57.1':
-    resolution:
-      {
-        integrity: sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==,
-      }
+    resolution: {integrity: sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==}
     cpu: [x64]
     os: [openbsd]
 
   '@rollup/rollup-openharmony-arm64@4.57.1':
-    resolution:
-      {
-        integrity: sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==,
-      }
+    resolution: {integrity: sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==}
     cpu: [arm64]
     os: [openharmony]
 
   '@rollup/rollup-win32-arm64-msvc@4.57.1':
-    resolution:
-      {
-        integrity: sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==,
-      }
+    resolution: {integrity: sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==}
     cpu: [arm64]
     os: [win32]
 
   '@rollup/rollup-win32-ia32-msvc@4.57.1':
-    resolution:
-      {
-        integrity: sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==,
-      }
+    resolution: {integrity: sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==}
     cpu: [ia32]
     os: [win32]
 
   '@rollup/rollup-win32-x64-gnu@4.57.1':
-    resolution:
-      {
-        integrity: sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==,
-      }
+    resolution: {integrity: sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==}
     cpu: [x64]
     os: [win32]
 
   '@rollup/rollup-win32-x64-msvc@4.57.1':
-    resolution:
-      {
-        integrity: sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==,
-      }
+    resolution: {integrity: sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==}
     cpu: [x64]
     os: [win32]
 
   '@sigstore/bundle@2.3.2':
-    resolution:
-      {
-        integrity: sha512-wueKWDk70QixNLB363yHc2D2ItTgYiMTdPwK8D9dKQMR3ZQ0c35IxP5xnwQ8cNLoCgCRcHf14kE+CLIvNX1zmA==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-wueKWDk70QixNLB363yHc2D2ItTgYiMTdPwK8D9dKQMR3ZQ0c35IxP5xnwQ8cNLoCgCRcHf14kE+CLIvNX1zmA==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@sigstore/core@1.1.0':
-    resolution:
-      {
-        integrity: sha512-JzBqdVIyqm2FRQCulY6nbQzMpJJpSiJ8XXWMhtOX9eKgaXXpfNOF53lzQEjIydlStnd/eFtuC1dW4VYdD93oRg==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-JzBqdVIyqm2FRQCulY6nbQzMpJJpSiJ8XXWMhtOX9eKgaXXpfNOF53lzQEjIydlStnd/eFtuC1dW4VYdD93oRg==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@sigstore/protobuf-specs@0.3.3':
-    resolution:
-      {
-        integrity: sha512-RpacQhBlwpBWd7KEJsRKcBQalbV28fvkxwTOJIqhIuDysMMaJW47V4OqW30iJB9uRpqOSxxEAQFdr8tTattReQ==,
-      }
-    engines: { node: ^18.17.0 || >=20.5.0 }
+    resolution: {integrity: sha512-RpacQhBlwpBWd7KEJsRKcBQalbV28fvkxwTOJIqhIuDysMMaJW47V4OqW30iJB9uRpqOSxxEAQFdr8tTattReQ==}
+    engines: {node: ^18.17.0 || >=20.5.0}
 
   '@sigstore/sign@2.3.2':
-    resolution:
-      {
-        integrity: sha512-5Vz5dPVuunIIvC5vBb0APwo7qKA4G9yM48kPWJT+OEERs40md5GoUR1yedwpekWZ4m0Hhw44m6zU+ObsON+iDA==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-5Vz5dPVuunIIvC5vBb0APwo7qKA4G9yM48kPWJT+OEERs40md5GoUR1yedwpekWZ4m0Hhw44m6zU+ObsON+iDA==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@sigstore/tuf@2.3.4':
-    resolution:
-      {
-        integrity: sha512-44vtsveTPUpqhm9NCrbU8CWLe3Vck2HO1PNLw7RIajbB7xhtn5RBPm1VNSCMwqGYHhDsBJG8gDF0q4lgydsJvw==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-44vtsveTPUpqhm9NCrbU8CWLe3Vck2HO1PNLw7RIajbB7xhtn5RBPm1VNSCMwqGYHhDsBJG8gDF0q4lgydsJvw==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@sigstore/verify@1.2.1':
-    resolution:
-      {
-        integrity: sha512-8iKx79/F73DKbGfRf7+t4dqrc0bRr0thdPrxAtCKWRm/F0tG71i6O1rvlnScncJLLBZHn3h8M3c1BSUAb9yu8g==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-8iKx79/F73DKbGfRf7+t4dqrc0bRr0thdPrxAtCKWRm/F0tG71i6O1rvlnScncJLLBZHn3h8M3c1BSUAb9yu8g==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@sinclair/typebox@0.27.8':
-    resolution:
-      {
-        integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==,
-      }
+    resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==}
 
   '@sinclair/typebox@0.34.47':
-    resolution:
-      {
-        integrity: sha512-ZGIBQ+XDvO5JQku9wmwtabcVTHJsgSWAHYtVuM9pBNNR5E88v6Jcj/llpmsjivig5X8A8HHOb4/mbEKPS5EvAw==,
-      }
+    resolution: {integrity: sha512-ZGIBQ+XDvO5JQku9wmwtabcVTHJsgSWAHYtVuM9pBNNR5E88v6Jcj/llpmsjivig5X8A8HHOb4/mbEKPS5EvAw==}
 
   '@sinclair/typebox@0.34.49':
-    resolution:
-      {
-        integrity: sha512-brySQQs7Jtn0joV8Xh9ZV/hZb9Ozb0pmazDIASBkYKCjXrXU3mpcFahmK/z4YDhGkQvP9mWJbVyahdtU5wQA+A==,
-      }
+    resolution: {integrity: sha512-brySQQs7Jtn0joV8Xh9ZV/hZb9Ozb0pmazDIASBkYKCjXrXU3mpcFahmK/z4YDhGkQvP9mWJbVyahdtU5wQA+A==}
 
   '@sinonjs/commons@3.0.1':
-    resolution:
-      {
-        integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==,
-      }
+    resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==}
 
   '@sinonjs/fake-timers@15.4.0':
-    resolution:
-      {
-        integrity: sha512-DsG+8/LscQIQg68J6Ef3dv10u6nVyetYn923s3/sus5eaGfTo1of5WMZSLf0UJc9KDuKPilPH0UDJCjvNbDNCA==,
-      }
+    resolution: {integrity: sha512-DsG+8/LscQIQg68J6Ef3dv10u6nVyetYn923s3/sus5eaGfTo1of5WMZSLf0UJc9KDuKPilPH0UDJCjvNbDNCA==}
 
   '@smithy/abort-controller@4.2.15':
-    resolution:
-      {
-        integrity: sha512-98zuTrdp06d5jhoIA7gBzEAh+4zZMywxdS1qiiUg0BOTq/EE4zc0bqgbSBKMcRKSNFZrpVFjspExiP7ScO2l5A==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-98zuTrdp06d5jhoIA7gBzEAh+4zZMywxdS1qiiUg0BOTq/EE4zc0bqgbSBKMcRKSNFZrpVFjspExiP7ScO2l5A==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/core@3.24.4':
-    resolution:
-      {
-        integrity: sha512-3UNRKEyQyAgVgM0LGlerCLm+ChZWZ1GPfde+jBEW6bm6bSBGU1p0EbblaUV3unbhwvidjLA5Zs3sOs7mnZwvAw==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-3UNRKEyQyAgVgM0LGlerCLm+ChZWZ1GPfde+jBEW6bm6bSBGU1p0EbblaUV3unbhwvidjLA5Zs3sOs7mnZwvAw==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/credential-provider-imds@4.3.4':
-    resolution:
-      {
-        integrity: sha512-vKW0MEFRU4Y3MkVZUkpJm+g9qyPGLCXhc0YLggUdSdBB4g7IaSSsCE75P9rBXyWHrXY1UYSQUl8/DwsTR7QciA==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-vKW0MEFRU4Y3MkVZUkpJm+g9qyPGLCXhc0YLggUdSdBB4g7IaSSsCE75P9rBXyWHrXY1UYSQUl8/DwsTR7QciA==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/fetch-http-handler@5.4.4':
-    resolution:
-      {
-        integrity: sha512-qM7AUKI4G6d7lNgaZD3lA1tWSolh5r6gcixfTZAPstVURfjIbvreVTPz+994M0yC3HbX4YYhDRgr31Xy3XwWOQ==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-qM7AUKI4G6d7lNgaZD3lA1tWSolh5r6gcixfTZAPstVURfjIbvreVTPz+994M0yC3HbX4YYhDRgr31Xy3XwWOQ==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/is-array-buffer@2.2.0':
-    resolution:
-      {
-        integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==,
-      }
-    engines: { node: '>=14.0.0' }
+    resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==}
+    engines: {node: '>=14.0.0'}
 
   '@smithy/node-http-handler@4.4.16':
-    resolution:
-      {
-        integrity: sha512-ULC8UCS/HivdCB3jhi+kLFYe4B5gxH2gi9vHBfEIiRrT2jfKiZNiETJSlzRtE6B26XbBHjPtc8iZKSNqMol9bw==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-ULC8UCS/HivdCB3jhi+kLFYe4B5gxH2gi9vHBfEIiRrT2jfKiZNiETJSlzRtE6B26XbBHjPtc8iZKSNqMol9bw==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/protocol-http@5.4.4':
-    resolution:
-      {
-        integrity: sha512-5VdJYIYsVt2GT+i0fp5gvWoJNrdFEFN16TrpNnAZHngYC/xgk5yni6O/qV3WlIpJjeLC8RfwoQiNTljCdbNXgw==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-5VdJYIYsVt2GT+i0fp5gvWoJNrdFEFN16TrpNnAZHngYC/xgk5yni6O/qV3WlIpJjeLC8RfwoQiNTljCdbNXgw==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/querystring-builder@4.3.4':
-    resolution:
-      {
-        integrity: sha512-cti+qc0OmNMtot9B2bOPyXfoXBBqcl/XEPGq32hORW0BZKNEK/bDp6xDHm5cFtV+96jj7vIZ17AHgf6ELJ9ZBw==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-cti+qc0OmNMtot9B2bOPyXfoXBBqcl/XEPGq32hORW0BZKNEK/bDp6xDHm5cFtV+96jj7vIZ17AHgf6ELJ9ZBw==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/signature-v4@5.4.4':
-    resolution:
-      {
-        integrity: sha512-e5UtkMvsatzBfbeBZjEOt0k0Z3BEsjTFL/n6fdO5vtBLe67tdy0dX7xw2DU7uZ3acwoHyeCqpU2Fzb7pxwHb6Q==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-e5UtkMvsatzBfbeBZjEOt0k0Z3BEsjTFL/n6fdO5vtBLe67tdy0dX7xw2DU7uZ3acwoHyeCqpU2Fzb7pxwHb6Q==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/types@4.14.2':
-    resolution:
-      {
-        integrity: sha512-P+otAxbV4CqBybp7EkcJCrig63yE2E7PuNVOmilVMRcx/O+QDzGULTrKsq4DV13gSfak9ObPrWaHl/9bL5YcWw==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-P+otAxbV4CqBybp7EkcJCrig63yE2E7PuNVOmilVMRcx/O+QDzGULTrKsq4DV13gSfak9ObPrWaHl/9bL5YcWw==}
+    engines: {node: '>=18.0.0'}
 
   '@smithy/util-buffer-from@2.2.0':
-    resolution:
-      {
-        integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==,
-      }
-    engines: { node: '>=14.0.0' }
+    resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==}
+    engines: {node: '>=14.0.0'}
 
   '@smithy/util-utf8@2.3.0':
-    resolution:
-      {
-        integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==,
-      }
-    engines: { node: '>=14.0.0' }
+    resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==}
+    engines: {node: '>=14.0.0'}
 
   '@styled-system/background@5.1.2':
-    resolution:
-      {
-        integrity: sha512-jtwH2C/U6ssuGSvwTN3ri/IyjdHb8W9X/g8Y0JLcrH02G+BW3OS8kZdHphF1/YyRklnrKrBT2ngwGUK6aqqV3A==,
-      }
+    resolution: {integrity: sha512-jtwH2C/U6ssuGSvwTN3ri/IyjdHb8W9X/g8Y0JLcrH02G+BW3OS8kZdHphF1/YyRklnrKrBT2ngwGUK6aqqV3A==}
 
   '@styled-system/border@5.1.5':
-    resolution:
-      {
-        integrity: sha512-JvddhNrnhGigtzWRCVuAHepniyVi6hBlimxWDVAdcTuk7aRn9BYJUwfHslURtwYFsF5FoEs8Zmr1oZq2M1AP0A==,
-      }
+    resolution: {integrity: sha512-JvddhNrnhGigtzWRCVuAHepniyVi6hBlimxWDVAdcTuk7aRn9BYJUwfHslURtwYFsF5FoEs8Zmr1oZq2M1AP0A==}
 
   '@styled-system/color@5.1.2':
-    resolution:
-      {
-        integrity: sha512-1kCkeKDZkt4GYkuFNKc7vJQMcOmTl3bJY3YBUs7fCNM6mMYJeT1pViQ2LwBSBJytj3AB0o4IdLBoepgSgGl5MA==,
-      }
+    resolution: {integrity: sha512-1kCkeKDZkt4GYkuFNKc7vJQMcOmTl3bJY3YBUs7fCNM6mMYJeT1pViQ2LwBSBJytj3AB0o4IdLBoepgSgGl5MA==}
 
   '@styled-system/core@5.1.2':
-    resolution:
-      {
-        integrity: sha512-XclBDdNIy7OPOsN4HBsawG2eiWfCcuFt6gxKn1x4QfMIgeO6TOlA2pZZ5GWZtIhCUqEPTgIBta6JXsGyCkLBYw==,
-      }
+    resolution: {integrity: sha512-XclBDdNIy7OPOsN4HBsawG2eiWfCcuFt6gxKn1x4QfMIgeO6TOlA2pZZ5GWZtIhCUqEPTgIBta6JXsGyCkLBYw==}
 
   '@styled-system/css@5.1.5':
-    resolution:
-      {
-        integrity: sha512-XkORZdS5kypzcBotAMPBoeckDs9aSZVkvrAlq5K3xP8IMAUek+x2O4NtwoSgkYkWWzVBu6DGdFZLR790QWGG+A==,
-      }
+    resolution: {integrity: sha512-XkORZdS5kypzcBotAMPBoeckDs9aSZVkvrAlq5K3xP8IMAUek+x2O4NtwoSgkYkWWzVBu6DGdFZLR790QWGG+A==}
 
   '@styled-system/flexbox@5.1.2':
-    resolution:
-      {
-        integrity: sha512-6hHV52+eUk654Y1J2v77B8iLeBNtc+SA3R4necsu2VVinSD7+XY5PCCEzBFaWs42dtOEDIa2lMrgL0YBC01mDQ==,
-      }
+    resolution: {integrity: sha512-6hHV52+eUk654Y1J2v77B8iLeBNtc+SA3R4necsu2VVinSD7+XY5PCCEzBFaWs42dtOEDIa2lMrgL0YBC01mDQ==}
 
   '@styled-system/grid@5.1.2':
-    resolution:
-      {
-        integrity: sha512-K3YiV1KyHHzgdNuNlaw8oW2ktMuGga99o1e/NAfTEi5Zsa7JXxzwEnVSDSBdJC+z6R8WYTCYRQC6bkVFcvdTeg==,
-      }
+    resolution: {integrity: sha512-K3YiV1KyHHzgdNuNlaw8oW2ktMuGga99o1e/NAfTEi5Zsa7JXxzwEnVSDSBdJC+z6R8WYTCYRQC6bkVFcvdTeg==}
 
   '@styled-system/layout@5.1.2':
-    resolution:
-      {
-        integrity: sha512-wUhkMBqSeacPFhoE9S6UF3fsMEKFv91gF4AdDWp0Aym1yeMPpqz9l9qS/6vjSsDPF7zOb5cOKC3tcKKOMuDCPw==,
-      }
+    resolution: {integrity: sha512-wUhkMBqSeacPFhoE9S6UF3fsMEKFv91gF4AdDWp0Aym1yeMPpqz9l9qS/6vjSsDPF7zOb5cOKC3tcKKOMuDCPw==}
 
   '@styled-system/position@5.1.2':
-    resolution:
-      {
-        integrity: sha512-60IZfMXEOOZe3l1mCu6sj/2NAyUmES2kR9Kzp7s2D3P4qKsZWxD1Se1+wJvevb+1TP+ZMkGPEYYXRyU8M1aF5A==,
-      }
+    resolution: {integrity: sha512-60IZfMXEOOZe3l1mCu6sj/2NAyUmES2kR9Kzp7s2D3P4qKsZWxD1Se1+wJvevb+1TP+ZMkGPEYYXRyU8M1aF5A==}
 
   '@styled-system/shadow@5.1.2':
-    resolution:
-      {
-        integrity: sha512-wqniqYb7XuZM7K7C0d1Euxc4eGtqEe/lvM0WjuAFsQVImiq6KGT7s7is+0bNI8O4Dwg27jyu4Lfqo/oIQXNzAg==,
-      }
+    resolution: {integrity: sha512-wqniqYb7XuZM7K7C0d1Euxc4eGtqEe/lvM0WjuAFsQVImiq6KGT7s7is+0bNI8O4Dwg27jyu4Lfqo/oIQXNzAg==}
 
   '@styled-system/space@5.1.2':
-    resolution:
-      {
-        integrity: sha512-+zzYpR8uvfhcAbaPXhH8QgDAV//flxqxSjHiS9cDFQQUSznXMQmxJegbhcdEF7/eNnJgHeIXv1jmny78kipgBA==,
-      }
+    resolution: {integrity: sha512-+zzYpR8uvfhcAbaPXhH8QgDAV//flxqxSjHiS9cDFQQUSznXMQmxJegbhcdEF7/eNnJgHeIXv1jmny78kipgBA==}
 
   '@styled-system/typography@5.1.2':
-    resolution:
-      {
-        integrity: sha512-BxbVUnN8N7hJ4aaPOd7wEsudeT7CxarR+2hns8XCX1zp0DFfbWw4xYa/olA0oQaqx7F1hzDg+eRaGzAJbF+jOg==,
-      }
+    resolution: {integrity: sha512-BxbVUnN8N7hJ4aaPOd7wEsudeT7CxarR+2hns8XCX1zp0DFfbWw4xYa/olA0oQaqx7F1hzDg+eRaGzAJbF+jOg==}
 
   '@styled-system/variant@5.1.5':
-    resolution:
-      {
-        integrity: sha512-Yn8hXAFoWIro8+Q5J8YJd/mP85Teiut3fsGVR9CAxwgNfIAiqlYxsk5iHU7VHJks/0KjL4ATSjmbtCDC/4l1qw==,
-      }
+    resolution: {integrity: sha512-Yn8hXAFoWIro8+Q5J8YJd/mP85Teiut3fsGVR9CAxwgNfIAiqlYxsk5iHU7VHJks/0KjL4ATSjmbtCDC/4l1qw==}
 
   '@swc/helpers@0.5.19':
-    resolution:
-      {
-        integrity: sha512-QamiFeIK3txNjgUTNppE6MiG3p7TdninpZu0E0PbqVh1a9FNLT2FRhisaa4NcaX52XVhA5l7Pk58Ft7Sqi/2sA==,
-      }
+    resolution: {integrity: sha512-QamiFeIK3txNjgUTNppE6MiG3p7TdninpZu0E0PbqVh1a9FNLT2FRhisaa4NcaX52XVhA5l7Pk58Ft7Sqi/2sA==}
 
   '@tanstack/query-core@5.90.20':
-    resolution:
-      {
-        integrity: sha512-OMD2HLpNouXEfZJWcKeVKUgQ5n+n3A2JFmBaScpNDUqSrQSjiveC7dKMe53uJUg1nDG16ttFPz2xfilz6i2uVg==,
-      }
+    resolution: {integrity: sha512-OMD2HLpNouXEfZJWcKeVKUgQ5n+n3A2JFmBaScpNDUqSrQSjiveC7dKMe53uJUg1nDG16ttFPz2xfilz6i2uVg==}
 
   '@tanstack/react-query@5.90.21':
-    resolution:
-      {
-        integrity: sha512-0Lu6y5t+tvlTJMTO7oh5NSpJfpg/5D41LlThfepTixPYkJ0sE2Jj0m0f6yYqujBwIXlId87e234+MxG3D3g7kg==,
-      }
+    resolution: {integrity: sha512-0Lu6y5t+tvlTJMTO7oh5NSpJfpg/5D41LlThfepTixPYkJ0sE2Jj0m0f6yYqujBwIXlId87e234+MxG3D3g7kg==}
     peerDependencies:
       react: ^18 || ^19
 
   '@tanstack/react-virtual@3.13.22':
-    resolution:
-      {
-        integrity: sha512-EaOrBBJLi3M0bTMQRjGkxLXRw7Gizwntoy5E2Q2UnSbML7Mo2a1P/Hfkw5tw9FLzK62bj34Jl6VNbQfRV6eJcA==,
-      }
+    resolution: {integrity: sha512-EaOrBBJLi3M0bTMQRjGkxLXRw7Gizwntoy5E2Q2UnSbML7Mo2a1P/Hfkw5tw9FLzK62bj34Jl6VNbQfRV6eJcA==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
       react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
   '@tanstack/virtual-core@3.13.22':
-    resolution:
-      {
-        integrity: sha512-isuUGKsc5TAPDoHSbWTbl1SCil54zOS2MiWz/9GCWHPUQOvNTQx8qJEWC7UWR0lShhbK0Lmkcf0SZYxvch7G3g==,
-      }
+    resolution: {integrity: sha512-isuUGKsc5TAPDoHSbWTbl1SCil54zOS2MiWz/9GCWHPUQOvNTQx8qJEWC7UWR0lShhbK0Lmkcf0SZYxvch7G3g==}
 
   '@testing-library/dom@10.4.1':
-    resolution:
-      {
-        integrity: sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==}
+    engines: {node: '>=18'}
 
   '@testing-library/dom@7.31.2':
-    resolution:
-      {
-        integrity: sha512-3UqjCpey6HiTZT92vODYLPxTBWlM8ZOOjr3LX5F37/VRipW2M1kX6I/Cm4VXzteZqfGfagg8yXywpcOgQBlNsQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-3UqjCpey6HiTZT92vODYLPxTBWlM8ZOOjr3LX5F37/VRipW2M1kX6I/Cm4VXzteZqfGfagg8yXywpcOgQBlNsQ==}
+    engines: {node: '>=10'}
 
   '@testing-library/jest-dom@5.11.10':
-    resolution:
-      {
-        integrity: sha512-FuKiq5xuk44Fqm0000Z9w0hjOdwZRNzgx7xGGxQYepWFZy+OYUMOT/wPI4nLYXCaVltNVpU1W/qmD88wLWDsqQ==,
-      }
-    engines: { node: '>=8', npm: '>=6', yarn: '>=1' }
+    resolution: {integrity: sha512-FuKiq5xuk44Fqm0000Z9w0hjOdwZRNzgx7xGGxQYepWFZy+OYUMOT/wPI4nLYXCaVltNVpU1W/qmD88wLWDsqQ==}
+    engines: {node: '>=8', npm: '>=6', yarn: '>=1'}
 
   '@testing-library/react@11.2.5':
-    resolution:
-      {
-        integrity: sha512-yEx7oIa/UWLe2F2dqK0FtMF9sJWNXD+2PPtp39BvE0Kh9MJ9Kl0HrZAgEuhUJR+Lx8Di6Xz+rKwSdEPY2UV8ZQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-yEx7oIa/UWLe2F2dqK0FtMF9sJWNXD+2PPtp39BvE0Kh9MJ9Kl0HrZAgEuhUJR+Lx8Di6Xz+rKwSdEPY2UV8ZQ==}
+    engines: {node: '>=10'}
     peerDependencies:
       react: '*'
       react-dom: '*'
 
   '@testing-library/react@16.3.2':
-    resolution:
-      {
-        integrity: sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==}
+    engines: {node: '>=18'}
     peerDependencies:
       '@testing-library/dom': ^10.0.0
       '@types/react': ^18.0.0 || ^19.0.0
@@ -7078,1789 +5841,1004 @@ packages:
         optional: true
 
   '@tsconfig/node10@1.0.12':
-    resolution:
-      {
-        integrity: sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ==,
-      }
+    resolution: {integrity: sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ==}
 
   '@tsconfig/node12@1.0.11':
-    resolution:
-      {
-        integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==,
-      }
+    resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==}
 
   '@tsconfig/node14@1.0.3':
-    resolution:
-      {
-        integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==,
-      }
+    resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==}
 
   '@tsconfig/node16@1.0.4':
-    resolution:
-      {
-        integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==,
-      }
+    resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
 
   '@tufjs/canonical-json@2.0.0':
-    resolution:
-      {
-        integrity: sha512-yVtV8zsdo8qFHe+/3kw81dSLyF7D576A5cCFCi4X7B39tWT7SekaEFUnvnWJHz+9qO7qJTah1JbrDjWKqFtdWA==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-yVtV8zsdo8qFHe+/3kw81dSLyF7D576A5cCFCi4X7B39tWT7SekaEFUnvnWJHz+9qO7qJTah1JbrDjWKqFtdWA==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@tufjs/models@2.0.1':
-    resolution:
-      {
-        integrity: sha512-92F7/SFyufn4DXsha9+QfKnN03JGqtMFMXgSHbZOo8JG59WkTni7UzAouNQDf7AuP9OAMxVOPQcqG3sB7w+kkg==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-92F7/SFyufn4DXsha9+QfKnN03JGqtMFMXgSHbZOo8JG59WkTni7UzAouNQDf7AuP9OAMxVOPQcqG3sB7w+kkg==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   '@tybys/wasm-util@0.10.2':
-    resolution:
-      {
-        integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==,
-      }
+    resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
 
   '@tybys/wasm-util@0.9.0':
-    resolution:
-      {
-        integrity: sha512-6+7nlbMVX/PVDCwaIQ8nTOPveOcFLSt8GcXdx8hD0bt39uWxYT88uXzqTd4fTvqta7oeUJqudepapKNt2DYJFw==,
-      }
+    resolution: {integrity: sha512-6+7nlbMVX/PVDCwaIQ8nTOPveOcFLSt8GcXdx8hD0bt39uWxYT88uXzqTd4fTvqta7oeUJqudepapKNt2DYJFw==}
 
   '@types/accept-language-parser@1.5.8':
-    resolution:
-      {
-        integrity: sha512-6+dKdh9q/I8xDBnKQKddCBKaWBWLmJ97HTiSbAXVpL7LEgDfOkKF98UVCaZ5KJrtdN5Wa5ndXUiqD3XR9XGqWQ==,
-      }
+    resolution: {integrity: sha512-6+dKdh9q/I8xDBnKQKddCBKaWBWLmJ97HTiSbAXVpL7LEgDfOkKF98UVCaZ5KJrtdN5Wa5ndXUiqD3XR9XGqWQ==}
 
   '@types/accepts@1.3.7':
-    resolution:
-      {
-        integrity: sha512-Pay9fq2lM2wXPWbteBsRAGiWH2hig4ZE2asK+mm7kUzlxRTfL961rj89I6zV/E3PcIkDqyuBEcMxFT7rccugeQ==,
-      }
+    resolution: {integrity: sha512-Pay9fq2lM2wXPWbteBsRAGiWH2hig4ZE2asK+mm7kUzlxRTfL961rj89I6zV/E3PcIkDqyuBEcMxFT7rccugeQ==}
 
   '@types/aria-query@4.2.2':
-    resolution:
-      {
-        integrity: sha512-HnYpAE1Y6kRyKM/XkEuiRQhTHvkzMBurTHnpFLYLBGPIylZNPs9jJcuOOYWxPLJCSEtmZT0Y8rHDokKN7rRTig==,
-      }
+    resolution: {integrity: sha512-HnYpAE1Y6kRyKM/XkEuiRQhTHvkzMBurTHnpFLYLBGPIylZNPs9jJcuOOYWxPLJCSEtmZT0Y8rHDokKN7rRTig==}
 
   '@types/aria-query@5.0.4':
-    resolution:
-      {
-        integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==,
-      }
+    resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==}
 
   '@types/babel__core@7.20.5':
-    resolution:
-      {
-        integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==,
-      }
+    resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
 
   '@types/babel__generator@7.27.0':
-    resolution:
-      {
-        integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==,
-      }
+    resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==}
 
   '@types/babel__template@7.4.4':
-    resolution:
-      {
-        integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==,
-      }
+    resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
 
   '@types/babel__traverse@7.28.0':
-    resolution:
-      {
-        integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==,
-      }
+    resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==}
 
   '@types/body-parser@1.19.6':
-    resolution:
-      {
-        integrity: sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==,
-      }
+    resolution: {integrity: sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==}
 
   '@types/connect@3.4.38':
-    resolution:
-      {
-        integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==,
-      }
+    resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==}
 
   '@types/content-disposition@0.5.9':
-    resolution:
-      {
-        integrity: sha512-8uYXI3Gw35MhiVYhG3s295oihrxRyytcRHjSjqnqZVDDy/xcGBRny7+Xj1Wgfhv5QzRtN2hB2dVRBUX9XW3UcQ==,
-      }
+    resolution: {integrity: sha512-8uYXI3Gw35MhiVYhG3s295oihrxRyytcRHjSjqnqZVDDy/xcGBRny7+Xj1Wgfhv5QzRtN2hB2dVRBUX9XW3UcQ==}
 
   '@types/cookie-parser@1.4.10':
-    resolution:
-      {
-        integrity: sha512-B4xqkqfZ8Wek+rCOeRxsjMS9OgvzebEzzLYw7NHYuvzb7IdxOkI0ZHGgeEBX4PUM7QGVvNSK60T3OvWj3YfBRg==,
-      }
+    resolution: {integrity: sha512-B4xqkqfZ8Wek+rCOeRxsjMS9OgvzebEzzLYw7NHYuvzb7IdxOkI0ZHGgeEBX4PUM7QGVvNSK60T3OvWj3YfBRg==}
     peerDependencies:
       '@types/express': '*'
 
   '@types/cookiejar@2.1.5':
-    resolution:
-      {
-        integrity: sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q==,
-      }
+    resolution: {integrity: sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q==}
 
   '@types/cookies@0.9.2':
-    resolution:
-      {
-        integrity: sha512-1AvkDdZM2dbyFybL4fxpuNCaWyv//0AwsuUk2DWeXyM1/5ZKm6W3z6mQi24RZ4l2ucY+bkSHzbDVpySqPGuV8A==,
-      }
+    resolution: {integrity: sha512-1AvkDdZM2dbyFybL4fxpuNCaWyv//0AwsuUk2DWeXyM1/5ZKm6W3z6mQi24RZ4l2ucY+bkSHzbDVpySqPGuV8A==}
 
   '@types/cors@2.8.19':
-    resolution:
-      {
-        integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==,
-      }
+    resolution: {integrity: sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==}
 
   '@types/estree@1.0.8':
-    resolution:
-      {
-        integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==,
-      }
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
   '@types/express-serve-static-core@5.1.0':
-    resolution:
-      {
-        integrity: sha512-jnHMsrd0Mwa9Cf4IdOzbz543y4XJepXrbia2T4b6+spXC2We3t1y6K44D3mR8XMFSXMCf3/l7rCgddfx7UNVBA==,
-      }
+    resolution: {integrity: sha512-jnHMsrd0Mwa9Cf4IdOzbz543y4XJepXrbia2T4b6+spXC2We3t1y6K44D3mR8XMFSXMCf3/l7rCgddfx7UNVBA==}
 
   '@types/express@5.0.6':
-    resolution:
-      {
-        integrity: sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==,
-      }
+    resolution: {integrity: sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA==}
 
   '@types/geojson@7946.0.16':
-    resolution:
-      {
-        integrity: sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==,
-      }
+    resolution: {integrity: sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==}
 
   '@types/graphql-upload@8.0.12':
-    resolution:
-      {
-        integrity: sha512-M0ZPZqNUzKNB16q5woEzgG/Q8DjICV80K7JvDSRnDmDFfrRdfFX/n6PbmqAN7gCzECcHVnw1gk6N4Cg0FwxCqA==,
-      }
+    resolution: {integrity: sha512-M0ZPZqNUzKNB16q5woEzgG/Q8DjICV80K7JvDSRnDmDFfrRdfFX/n6PbmqAN7gCzECcHVnw1gk6N4Cg0FwxCqA==}
 
   '@types/http-assert@1.5.6':
-    resolution:
-      {
-        integrity: sha512-TTEwmtjgVbYAzZYWyeHPrrtWnfVkm8tQkP8P21uQifPgMRgjrow3XDEYqucuC8SKZJT7pUnhU/JymvjggxO9vw==,
-      }
+    resolution: {integrity: sha512-TTEwmtjgVbYAzZYWyeHPrrtWnfVkm8tQkP8P21uQifPgMRgjrow3XDEYqucuC8SKZJT7pUnhU/JymvjggxO9vw==}
 
   '@types/http-errors@2.0.5':
-    resolution:
-      {
-        integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==,
-      }
+    resolution: {integrity: sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==}
 
   '@types/istanbul-lib-coverage@2.0.6':
-    resolution:
-      {
-        integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==,
-      }
+    resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==}
 
   '@types/istanbul-lib-report@3.0.3':
-    resolution:
-      {
-        integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==,
-      }
+    resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==}
 
   '@types/istanbul-reports@3.0.4':
-    resolution:
-      {
-        integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==,
-      }
+    resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==}
 
   '@types/jest-in-case@1.0.9':
-    resolution:
-      {
-        integrity: sha512-tapHpzWGjCC/hxYJyzbJ/5ZV6rA2153Sve5lGJUAIA1Jzrphfp27TznAWfGeXf+d8TLN7zMujaC0UwNQwSJaQg==,
-      }
+    resolution: {integrity: sha512-tapHpzWGjCC/hxYJyzbJ/5ZV6rA2153Sve5lGJUAIA1Jzrphfp27TznAWfGeXf+d8TLN7zMujaC0UwNQwSJaQg==}
 
   '@types/jest@30.0.0':
-    resolution:
-      {
-        integrity: sha512-XTYugzhuwqWjws0CVz8QpM36+T+Dz5mTEBKhNs/esGLnCIlGdRy+Dq78NRjd7ls7r8BC8ZRMOrKlkO1hU0JOwA==,
-      }
+    resolution: {integrity: sha512-XTYugzhuwqWjws0CVz8QpM36+T+Dz5mTEBKhNs/esGLnCIlGdRy+Dq78NRjd7ls7r8BC8ZRMOrKlkO1hU0JOwA==}
 
   '@types/js-yaml@4.0.9':
-    resolution:
-      {
-        integrity: sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==,
-      }
+    resolution: {integrity: sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==}
 
   '@types/jsdom@21.1.7':
-    resolution:
-      {
-        integrity: sha512-yOriVnggzrnQ3a9OKOCxaVuSug3w3/SbOj5i7VwXWZEyUNl3bLF9V3MfxGbZKuwqJOQyRfqXyROBB1CoZLFWzA==,
-      }
+    resolution: {integrity: sha512-yOriVnggzrnQ3a9OKOCxaVuSug3w3/SbOj5i7VwXWZEyUNl3bLF9V3MfxGbZKuwqJOQyRfqXyROBB1CoZLFWzA==}
 
   '@types/json-schema@7.0.15':
-    resolution:
-      {
-        integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==,
-      }
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
 
   '@types/keygrip@1.0.6':
-    resolution:
-      {
-        integrity: sha512-lZuNAY9xeJt7Bx4t4dx0rYCDqGPW8RXhQZK1td7d4H6E9zYbLoOtjBvfwdTKpsyxQI/2jv+armjX/RW+ZNpXOQ==,
-      }
+    resolution: {integrity: sha512-lZuNAY9xeJt7Bx4t4dx0rYCDqGPW8RXhQZK1td7d4H6E9zYbLoOtjBvfwdTKpsyxQI/2jv+armjX/RW+ZNpXOQ==}
 
   '@types/koa-compose@3.2.9':
-    resolution:
-      {
-        integrity: sha512-BroAZ9FTvPiCy0Pi8tjD1OfJ7bgU1gQf0eR6e1Vm+JJATy9eKOG3hQMFtMciMawiSOVnLMdmUOC46s7HBhSTsA==,
-      }
+    resolution: {integrity: sha512-BroAZ9FTvPiCy0Pi8tjD1OfJ7bgU1gQf0eR6e1Vm+JJATy9eKOG3hQMFtMciMawiSOVnLMdmUOC46s7HBhSTsA==}
 
   '@types/koa@3.0.1':
-    resolution:
-      {
-        integrity: sha512-VkB6WJUQSe0zBpR+Q7/YIUESGp5wPHcaXr0xueU5W0EOUWtlSbblsl+Kl31lyRQ63nIILh0e/7gXjQ09JXJIHw==,
-      }
+    resolution: {integrity: sha512-VkB6WJUQSe0zBpR+Q7/YIUESGp5wPHcaXr0xueU5W0EOUWtlSbblsl+Kl31lyRQ63nIILh0e/7gXjQ09JXJIHw==}
 
   '@types/methods@1.1.4':
-    resolution:
-      {
-        integrity: sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ==,
-      }
+    resolution: {integrity: sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ==}
 
   '@types/minimatch@3.0.5':
-    resolution:
-      {
-        integrity: sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==,
-      }
+    resolution: {integrity: sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==}
 
   '@types/minimist@1.2.5':
-    resolution:
-      {
-        integrity: sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==,
-      }
+    resolution: {integrity: sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==}
 
   '@types/node@22.19.11':
-    resolution:
-      {
-        integrity: sha512-BH7YwL6rA93ReqeQS1c4bsPpcfOmJasG+Fkr6Y59q83f9M1WcBRHR2vM+P9eOisYRcN3ujQoiZY8uk5W+1WL8w==,
-      }
+    resolution: {integrity: sha512-BH7YwL6rA93ReqeQS1c4bsPpcfOmJasG+Fkr6Y59q83f9M1WcBRHR2vM+P9eOisYRcN3ujQoiZY8uk5W+1WL8w==}
 
   '@types/node@22.19.15':
-    resolution:
-      {
-        integrity: sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==,
-      }
+    resolution: {integrity: sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==}
 
   '@types/node@22.19.19':
-    resolution:
-      {
-        integrity: sha512-dyh/xO2Fh5bYrfWaaqGrRQQGkNdmYw6AmaAUvYeUMNTWQtvb796ikLdmTchRmOlOiIJ1TDXfWgVx1QkUlQ6Hew==,
-      }
+    resolution: {integrity: sha512-dyh/xO2Fh5bYrfWaaqGrRQQGkNdmYw6AmaAUvYeUMNTWQtvb796ikLdmTchRmOlOiIJ1TDXfWgVx1QkUlQ6Hew==}
 
   '@types/node@25.9.1':
-    resolution:
-      {
-        integrity: sha512-xfrlY7UD5rMJk3ZVJP8BNzS28J36YJg+xp+LPXV1TdWxr8uMH5A860QNxYDGQe/ylDSgjxE52Q9VnO7p75tJxg==,
-      }
+    resolution: {integrity: sha512-xfrlY7UD5rMJk3ZVJP8BNzS28J36YJg+xp+LPXV1TdWxr8uMH5A860QNxYDGQe/ylDSgjxE52Q9VnO7p75tJxg==}
 
   '@types/nodemailer@7.0.11':
-    resolution:
-      {
-        integrity: sha512-E+U4RzR2dKrx+u3N4DlsmLaDC6mMZOM/TPROxA0UAPiTgI0y4CEFBmZE+coGWTjakDriRsXG368lNk1u9Q0a2g==,
-      }
+    resolution: {integrity: sha512-E+U4RzR2dKrx+u3N4DlsmLaDC6mMZOM/TPROxA0UAPiTgI0y4CEFBmZE+coGWTjakDriRsXG368lNk1u9Q0a2g==}
 
   '@types/normalize-package-data@2.4.4':
-    resolution:
-      {
-        integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==,
-      }
+    resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==}
 
   '@types/pg-copy-streams@1.2.5':
-    resolution:
-      {
-        integrity: sha512-7D6/GYW2uHIaVU6S/5omI+6RZnwlZBpLQDZAH83xX1rjxAOK0f6/deKyyUTewxqts145VIGn6XWYz1YGf50G5g==,
-      }
+    resolution: {integrity: sha512-7D6/GYW2uHIaVU6S/5omI+6RZnwlZBpLQDZAH83xX1rjxAOK0f6/deKyyUTewxqts145VIGn6XWYz1YGf50G5g==}
 
   '@types/pg@8.20.0':
-    resolution:
-      {
-        integrity: sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow==,
-      }
+    resolution: {integrity: sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow==}
 
   '@types/pluralize@0.0.33':
-    resolution:
-      {
-        integrity: sha512-JOqsl+ZoCpP4e8TDke9W79FDcSgPAR0l6pixx2JHkhnRjvShyYiAYw2LVsnA7K08Y6DeOnaU6ujmENO4os/cYg==,
-      }
+    resolution: {integrity: sha512-JOqsl+ZoCpP4e8TDke9W79FDcSgPAR0l6pixx2JHkhnRjvShyYiAYw2LVsnA7K08Y6DeOnaU6ujmENO4os/cYg==}
 
   '@types/qs@6.14.0':
-    resolution:
-      {
-        integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==,
-      }
+    resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}
 
   '@types/range-parser@1.2.7':
-    resolution:
-      {
-        integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==,
-      }
+    resolution: {integrity: sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==}
 
   '@types/react-dom@19.2.3':
-    resolution:
-      {
-        integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==,
-      }
+    resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}
     peerDependencies:
       '@types/react': ^19.2.0
 
   '@types/react@19.2.14':
-    resolution:
-      {
-        integrity: sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==,
-      }
+    resolution: {integrity: sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==}
 
   '@types/react@19.2.15':
-    resolution:
-      {
-        integrity: sha512-eRwcGNHve+E8qtEQSSRl6urh+rFop4v8gm6O8rGv25CodbvFdLjA1vVQ1KkiFE0w0UPOnb8tDiFKL5lp0rtY5Q==,
-      }
+    resolution: {integrity: sha512-eRwcGNHve+E8qtEQSSRl6urh+rFop4v8gm6O8rGv25CodbvFdLjA1vVQ1KkiFE0w0UPOnb8tDiFKL5lp0rtY5Q==}
 
   '@types/request-ip@0.0.41':
-    resolution:
-      {
-        integrity: sha512-Qzz0PM2nSZej4lsLzzNfADIORZhhxO7PED0fXpg4FjXiHuJ/lMyUg+YFF5q8x9HPZH3Gl6N+NOM8QZjItNgGKg==,
-      }
+    resolution: {integrity: sha512-Qzz0PM2nSZej4lsLzzNfADIORZhhxO7PED0fXpg4FjXiHuJ/lMyUg+YFF5q8x9HPZH3Gl6N+NOM8QZjItNgGKg==}
 
   '@types/semver@7.7.1':
-    resolution:
-      {
-        integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==,
-      }
+    resolution: {integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==}
 
   '@types/send@1.2.1':
-    resolution:
-      {
-        integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==,
-      }
+    resolution: {integrity: sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==}
 
   '@types/serve-static@2.2.0':
-    resolution:
-      {
-        integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==,
-      }
+    resolution: {integrity: sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==}
 
   '@types/shelljs@0.10.0':
-    resolution:
-      {
-        integrity: sha512-OEfyhE5Ox+FeoHbhrEDwm0kXxntO6nsyMRCFvNsIBHPZu5rV1w2OjPcLclaC/IZ1TlzZPgbeMfwAZEi5N238yQ==,
-      }
+    resolution: {integrity: sha512-OEfyhE5Ox+FeoHbhrEDwm0kXxntO6nsyMRCFvNsIBHPZu5rV1w2OjPcLclaC/IZ1TlzZPgbeMfwAZEi5N238yQ==}
 
   '@types/smtp-server@3.5.13':
-    resolution:
-      {
-        integrity: sha512-S3rGl2KbViH+98/CgHipPIWgtAFnjxLsppxIRbgJHNuZL7Y+py+7kZjT7xS+wOmCxYTn4O7IqLqkvekg99MDVQ==,
-      }
+    resolution: {integrity: sha512-S3rGl2KbViH+98/CgHipPIWgtAFnjxLsppxIRbgJHNuZL7Y+py+7kZjT7xS+wOmCxYTn4O7IqLqkvekg99MDVQ==}
 
   '@types/stack-utils@2.0.3':
-    resolution:
-      {
-        integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==,
-      }
+    resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==}
 
   '@types/superagent@8.1.9':
-    resolution:
-      {
-        integrity: sha512-pTVjI73witn+9ILmoJdajHGW2jkSaOzhiFYF1Rd3EQ94kymLqB9PjD9ISg7WaALC7+dCHT0FGe9T2LktLq/3GQ==,
-      }
+    resolution: {integrity: sha512-pTVjI73witn+9ILmoJdajHGW2jkSaOzhiFYF1Rd3EQ94kymLqB9PjD9ISg7WaALC7+dCHT0FGe9T2LktLq/3GQ==}
 
   '@types/supertest@7.2.0':
-    resolution:
-      {
-        integrity: sha512-uh2Lv57xvggst6lCqNdFAmDSvoMG7M/HDtX4iUCquxQ5EGPtaPM5PL5Hmi7LCvOG8db7YaCPNJEeoI8s/WzIQw==,
-      }
+    resolution: {integrity: sha512-uh2Lv57xvggst6lCqNdFAmDSvoMG7M/HDtX4iUCquxQ5EGPtaPM5PL5Hmi7LCvOG8db7YaCPNJEeoI8s/WzIQw==}
 
   '@types/testing-library__jest-dom@5.14.9':
-    resolution:
-      {
-        integrity: sha512-FSYhIjFlfOpGSRyVoMBMuS3ws5ehFQODymf3vlI7U1K8c7PHwWwFY7VREfmsuzHSOnoKs/9/Y983ayOs7eRzqw==,
-      }
+    resolution: {integrity: sha512-FSYhIjFlfOpGSRyVoMBMuS3ws5ehFQODymf3vlI7U1K8c7PHwWwFY7VREfmsuzHSOnoKs/9/Y983ayOs7eRzqw==}
 
   '@types/tough-cookie@4.0.5':
-    resolution:
-      {
-        integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==,
-      }
+    resolution: {integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==}
 
   '@types/ws@8.18.1':
-    resolution:
-      {
-        integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==,
-      }
+    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
 
   '@types/yargs-parser@21.0.3':
-    resolution:
-      {
-        integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==,
-      }
+    resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==}
 
   '@types/yargs@15.0.20':
-    resolution:
-      {
-        integrity: sha512-KIkX+/GgfFitlASYCGoSF+T4XRXhOubJLhkLVtSfsRTe9jWMmuM2g28zQ41BtPTG7TRBb2xHW+LCNVE9QR/vsg==,
-      }
+    resolution: {integrity: sha512-KIkX+/GgfFitlASYCGoSF+T4XRXhOubJLhkLVtSfsRTe9jWMmuM2g28zQ41BtPTG7TRBb2xHW+LCNVE9QR/vsg==}
 
   '@types/yargs@17.0.35':
-    resolution:
-      {
-        integrity: sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==,
-      }
+    resolution: {integrity: sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==}
 
   '@typescript-eslint/eslint-plugin@8.59.4':
-    resolution:
-      {
-        integrity: sha512-PegsU+XfyJJNjd4+u/k6f9yTyp0lEXXiPopUNobZcIAUJFGICFLN+sP0Rb3JehVmiij1Ph0dFGYqODoRo/2+6A==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-PegsU+XfyJJNjd4+u/k6f9yTyp0lEXXiPopUNobZcIAUJFGICFLN+sP0Rb3JehVmiij1Ph0dFGYqODoRo/2+6A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       '@typescript-eslint/parser': ^8.59.4
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
   '@typescript-eslint/parser@8.59.4':
-    resolution:
-      {
-        integrity: sha512-zORHqO/tuhxY1zWuTvMUqddRxpiFJ72xVfcNoWpqdLjs6lfPbuQBJuW4pk+49/uBMy7Ssr4bzgjiKmmDB1UbZQ==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-zORHqO/tuhxY1zWuTvMUqddRxpiFJ72xVfcNoWpqdLjs6lfPbuQBJuW4pk+49/uBMy7Ssr4bzgjiKmmDB1UbZQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
   '@typescript-eslint/project-service@8.59.4':
-    resolution:
-      {
-        integrity: sha512-Ly00Vu4oAacfDeHp2Zg85ioNG6l8HG+tN1D7J+xTHSxu9y0awYKJ2zH1rFBn8ZSfuGK+7FxK3Cgl3uAz0aZZLg==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-Ly00Vu4oAacfDeHp2Zg85ioNG6l8HG+tN1D7J+xTHSxu9y0awYKJ2zH1rFBn8ZSfuGK+7FxK3Cgl3uAz0aZZLg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
 
   '@typescript-eslint/scope-manager@8.59.4':
-    resolution:
-      {
-        integrity: sha512-mUeR/3H1WrTAddJrwut8OoPjfauaztMQmRwV5fQTUyNVJCLiUXXe4lGEyYIL2oFDpP7UtgbGJXCt72wT0z2S3Q==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-mUeR/3H1WrTAddJrwut8OoPjfauaztMQmRwV5fQTUyNVJCLiUXXe4lGEyYIL2oFDpP7UtgbGJXCt72wT0z2S3Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@typescript-eslint/tsconfig-utils@8.59.4':
-    resolution:
-      {
-        integrity: sha512-DLCpnKgD4alVxTBSKulK+gU1KCqOgUXfDRDXh2mZgzokQKa/70ax93I2uVO3m/LLvIAtWZIFoiifudmIqAxpMA==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-DLCpnKgD4alVxTBSKulK+gU1KCqOgUXfDRDXh2mZgzokQKa/70ax93I2uVO3m/LLvIAtWZIFoiifudmIqAxpMA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
 
   '@typescript-eslint/type-utils@8.59.4':
-    resolution:
-      {
-        integrity: sha512-uonTuPAAKr9XaBGqJ3LjYTh72zy5DyGesljO9gtmk/eFW0W1fRHjnwVYKB35Lm8d5Q5CluEW3gPHjTvZTmgrfA==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-uonTuPAAKr9XaBGqJ3LjYTh72zy5DyGesljO9gtmk/eFW0W1fRHjnwVYKB35Lm8d5Q5CluEW3gPHjTvZTmgrfA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
   '@typescript-eslint/types@8.59.4':
-    resolution:
-      {
-        integrity: sha512-F1o7WJcCq+bc8dwcO/YsSEOudAH8RDtaOhM6wcAQhcUsFhnWQl81JKy48q1hoxAU0qrzM89+31GYh1515Zde3Q==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-F1o7WJcCq+bc8dwcO/YsSEOudAH8RDtaOhM6wcAQhcUsFhnWQl81JKy48q1hoxAU0qrzM89+31GYh1515Zde3Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@typescript-eslint/typescript-estree@8.59.4':
-    resolution:
-      {
-        integrity: sha512-F+RuOmcDXo4+TPdfd/TCLS3m2nw8gE9XXyZLrA3JBfaA5tz9TtdkyD3YJFmPxulyc2cKbEok/CvFE3MgSLWnag==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-F+RuOmcDXo4+TPdfd/TCLS3m2nw8gE9XXyZLrA3JBfaA5tz9TtdkyD3YJFmPxulyc2cKbEok/CvFE3MgSLWnag==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
 
   '@typescript-eslint/utils@8.59.4':
-    resolution:
-      {
-        integrity: sha512-cYXeNAUsG4lJo5dbc1FcKm+JwIWrj1/UpTORsC6tGMjEZ81DYcvIr9/ueikhMa/Y/gDQYGp+YX9/xQrXje5BJw==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-cYXeNAUsG4lJo5dbc1FcKm+JwIWrj1/UpTORsC6tGMjEZ81DYcvIr9/ueikhMa/Y/gDQYGp+YX9/xQrXje5BJw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
   '@typescript-eslint/visitor-keys@8.59.4':
-    resolution:
-      {
-        integrity: sha512-U3gxVaDVnuZKhSspW/MzMxE1kq7zOdc072FcSNoqA1I9p8HyKbBFfEHoWckBAMgNMph4MamwS5iTVzFmrnt8TQ==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-U3gxVaDVnuZKhSspW/MzMxE1kq7zOdc072FcSNoqA1I9p8HyKbBFfEHoWckBAMgNMph4MamwS5iTVzFmrnt8TQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@ungap/structured-clone@1.3.1':
-    resolution:
-      {
-        integrity: sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==,
-      }
+    resolution: {integrity: sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==}
 
   '@unrs/resolver-binding-android-arm-eabi@1.12.2':
-    resolution:
-      {
-        integrity: sha512-g5T90pqg1bo/7mytQx6F4iBNC0Wsh9cu+z9veDbFjc7HjpesJFWD7QMS0NGStXM075+7dJPPVvBbpZlnrdpi/w==,
-      }
+    resolution: {integrity: sha512-g5T90pqg1bo/7mytQx6F4iBNC0Wsh9cu+z9veDbFjc7HjpesJFWD7QMS0NGStXM075+7dJPPVvBbpZlnrdpi/w==}
     cpu: [arm]
     os: [android]
 
   '@unrs/resolver-binding-android-arm64@1.12.2':
-    resolution:
-      {
-        integrity: sha512-YGCRZv/9GLhwmz6mYDeTsm/92BAyR28l6c2ReweVW5pWgfsitWLY8upvfRlGdoyD8HjeTHSYJWyZGD4KJA/nFQ==,
-      }
+    resolution: {integrity: sha512-YGCRZv/9GLhwmz6mYDeTsm/92BAyR28l6c2ReweVW5pWgfsitWLY8upvfRlGdoyD8HjeTHSYJWyZGD4KJA/nFQ==}
     cpu: [arm64]
     os: [android]
 
   '@unrs/resolver-binding-darwin-arm64@1.12.2':
-    resolution:
-      {
-        integrity: sha512-u9DiNT1auQMO20A9SyTuG3wUgQWB9Z7KjAg0uFuCDR1FsAY8A0CG2S6JpHS1xwm/w1G08bjXZDcyOCjv1WAm2w==,
-      }
+    resolution: {integrity: sha512-u9DiNT1auQMO20A9SyTuG3wUgQWB9Z7KjAg0uFuCDR1FsAY8A0CG2S6JpHS1xwm/w1G08bjXZDcyOCjv1WAm2w==}
     cpu: [arm64]
     os: [darwin]
 
   '@unrs/resolver-binding-darwin-x64@1.12.2':
-    resolution:
-      {
-        integrity: sha512-f7rPLi/T1HVKZu/u6t87lroib16n8vrSzcyxI7lg4BGO9UF26KhQL44sd9eOUgrTYhvRXtWOIZT5PejdPyJfUA==,
-      }
+    resolution: {integrity: sha512-f7rPLi/T1HVKZu/u6t87lroib16n8vrSzcyxI7lg4BGO9UF26KhQL44sd9eOUgrTYhvRXtWOIZT5PejdPyJfUA==}
     cpu: [x64]
     os: [darwin]
 
   '@unrs/resolver-binding-freebsd-x64@1.12.2':
-    resolution:
-      {
-        integrity: sha512-BpcOjWCJub6nRZUS2zA20pmLvjtqAtGejETaIyRLiZiQf++cbrjltLA5NN/xaXfqeOBOSlMFbemIl5/S5tljmg==,
-      }
+    resolution: {integrity: sha512-BpcOjWCJub6nRZUS2zA20pmLvjtqAtGejETaIyRLiZiQf++cbrjltLA5NN/xaXfqeOBOSlMFbemIl5/S5tljmg==}
     cpu: [x64]
     os: [freebsd]
 
   '@unrs/resolver-binding-linux-arm-gnueabihf@1.12.2':
-    resolution:
-      {
-        integrity: sha512-vZTDvdSISZjJx66OzJqtsOhzifbqRjbmI1Mnu49fQDwog5GtDI4QidRiEAYbZCRj9C8YZEW+3ZjqsyS9GR4k2A==,
-      }
+    resolution: {integrity: sha512-vZTDvdSISZjJx66OzJqtsOhzifbqRjbmI1Mnu49fQDwog5GtDI4QidRiEAYbZCRj9C8YZEW+3ZjqsyS9GR4k2A==}
     cpu: [arm]
     os: [linux]
 
   '@unrs/resolver-binding-linux-arm-musleabihf@1.12.2':
-    resolution:
-      {
-        integrity: sha512-BiPI+IrIlwcW4nLLMM21+B1dFPzd55yAVgVGrdgDjNef+ch03GdxrcyaIz8X9SsQirh/kCQ7mviyWlMxdh2D7g==,
-      }
+    resolution: {integrity: sha512-BiPI+IrIlwcW4nLLMM21+B1dFPzd55yAVgVGrdgDjNef+ch03GdxrcyaIz8X9SsQirh/kCQ7mviyWlMxdh2D7g==}
     cpu: [arm]
     os: [linux]
 
   '@unrs/resolver-binding-linux-arm64-gnu@1.12.2':
-    resolution:
-      {
-        integrity: sha512-zJc0H99FEPoFfSrNpa91HYfxzfAJCr502oxNK1cfdC9hlaFI43RT+JFCann9JUgZmLzzntChHyn13Sgn9ljHNg==,
-      }
+    resolution: {integrity: sha512-zJc0H99FEPoFfSrNpa91HYfxzfAJCr502oxNK1cfdC9hlaFI43RT+JFCann9JUgZmLzzntChHyn13Sgn9ljHNg==}
     cpu: [arm64]
     os: [linux]
+    libc: [glibc]
 
   '@unrs/resolver-binding-linux-arm64-musl@1.12.2':
-    resolution:
-      {
-        integrity: sha512-KQ3Lki6l+Pz1k/eBipN41ES+YUK30beLGb9YqcB1O542cyLCNE6GaxrfcY3T6EezmGGk84wb5XyO9loTM9tkcA==,
-      }
+    resolution: {integrity: sha512-KQ3Lki6l+Pz1k/eBipN41ES+YUK30beLGb9YqcB1O542cyLCNE6GaxrfcY3T6EezmGGk84wb5XyO9loTM9tkcA==}
     cpu: [arm64]
     os: [linux]
+    libc: [musl]
 
   '@unrs/resolver-binding-linux-loong64-gnu@1.12.2':
-    resolution:
-      {
-        integrity: sha512-3SJGEh1DborhG6pyxvhPzCT4bbSIVihsvgJc13P1bHG7KLdNDaF9T3gsTwFc7Jw/5Y5/iWOjkEx7Zy0NvCGX3Q==,
-      }
+    resolution: {integrity: sha512-3SJGEh1DborhG6pyxvhPzCT4bbSIVihsvgJc13P1bHG7KLdNDaF9T3gsTwFc7Jw/5Y5/iWOjkEx7Zy0NvCGX3Q==}
     cpu: [loong64]
     os: [linux]
+    libc: [glibc]
 
   '@unrs/resolver-binding-linux-loong64-musl@1.12.2':
-    resolution:
-      {
-        integrity: sha512-jiuG/Obbel7uw1PwHNFfrkiKhLAF6mnyZ6aWlOAVN9WqKm8v0OFGnciJIHu8+CMvXLQ8AD51LPzAoUfT21D5Ew==,
-      }
+    resolution: {integrity: sha512-jiuG/Obbel7uw1PwHNFfrkiKhLAF6mnyZ6aWlOAVN9WqKm8v0OFGnciJIHu8+CMvXLQ8AD51LPzAoUfT21D5Ew==}
     cpu: [loong64]
     os: [linux]
+    libc: [musl]
 
   '@unrs/resolver-binding-linux-ppc64-gnu@1.12.2':
-    resolution:
-      {
-        integrity: sha512-q7xRvVpmcfeL+LlZg8Pbbo6QaTZwDU5BaGZbwfhkEsXJn3Was8xYfE0RBH266xZt0rM6B7i8xAYIvjthuUIWHg==,
-      }
+    resolution: {integrity: sha512-q7xRvVpmcfeL+LlZg8Pbbo6QaTZwDU5BaGZbwfhkEsXJn3Was8xYfE0RBH266xZt0rM6B7i8xAYIvjthuUIWHg==}
     cpu: [ppc64]
     os: [linux]
+    libc: [glibc]
 
   '@unrs/resolver-binding-linux-riscv64-gnu@1.12.2':
-    resolution:
-      {
-        integrity: sha512-0CVdx6lcnT3Q9inOH8tsMIOJ6ImndllMjqJHg8RLVdB7Vq4SfkEXl9mCSsVNuNA4MCYycRicCUxPCabVHJRr6A==,
-      }
+    resolution: {integrity: sha512-0CVdx6lcnT3Q9inOH8tsMIOJ6ImndllMjqJHg8RLVdB7Vq4SfkEXl9mCSsVNuNA4MCYycRicCUxPCabVHJRr6A==}
     cpu: [riscv64]
     os: [linux]
+    libc: [glibc]
 
   '@unrs/resolver-binding-linux-riscv64-musl@1.12.2':
-    resolution:
-      {
-        integrity: sha512-iOwlRo9vnp6R6ohHQS11n0NnfdXx/omhkocmIfaPRpQhKZ+3BDMkkdRVh53qjkFkpPddf+FETA28NwGN7l5l+w==,
-      }
+    resolution: {integrity: sha512-iOwlRo9vnp6R6ohHQS11n0NnfdXx/omhkocmIfaPRpQhKZ+3BDMkkdRVh53qjkFkpPddf+FETA28NwGN7l5l+w==}
     cpu: [riscv64]
     os: [linux]
+    libc: [musl]
 
   '@unrs/resolver-binding-linux-s390x-gnu@1.12.2':
-    resolution:
-      {
-        integrity: sha512-HYJtLfXq94q8iZNFT1lknx258wlkkWhZeUXJRqzKBBUJ00CvZ+N33zgbCqimLjsyw5Va6uUxhVa12mI+kaveEw==,
-      }
+    resolution: {integrity: sha512-HYJtLfXq94q8iZNFT1lknx258wlkkWhZeUXJRqzKBBUJ00CvZ+N33zgbCqimLjsyw5Va6uUxhVa12mI+kaveEw==}
     cpu: [s390x]
     os: [linux]
+    libc: [glibc]
 
   '@unrs/resolver-binding-linux-x64-gnu@1.12.2':
-    resolution:
-      {
-        integrity: sha512-mPsUhunKKDih5O96Y6enDQyHc1SqBPlY1E/SfMWDM3EdJ95Z9CArPeCVwCCqbP45ljvivdEk8Fxn+SIb1rDAJQ==,
-      }
+    resolution: {integrity: sha512-mPsUhunKKDih5O96Y6enDQyHc1SqBPlY1E/SfMWDM3EdJ95Z9CArPeCVwCCqbP45ljvivdEk8Fxn+SIb1rDAJQ==}
     cpu: [x64]
     os: [linux]
+    libc: [glibc]
 
   '@unrs/resolver-binding-linux-x64-musl@1.12.2':
-    resolution:
-      {
-        integrity: sha512-azrt6+5ydLd8Vt210AAFis/lZevSfPw93EJRIJG+xPu4WCJ8K0kppCTpMyLPcKT7H15M4Jnt2tMp5bOvCkRC6A==,
-      }
+    resolution: {integrity: sha512-azrt6+5ydLd8Vt210AAFis/lZevSfPw93EJRIJG+xPu4WCJ8K0kppCTpMyLPcKT7H15M4Jnt2tMp5bOvCkRC6A==}
     cpu: [x64]
     os: [linux]
+    libc: [musl]
 
   '@unrs/resolver-binding-openharmony-arm64@1.12.2':
-    resolution:
-      {
-        integrity: sha512-YZ9hP4O0X9PQb8eO980qmLNGH4zT3I9+SZTdt0Pr0YyuGQhYKoOZkV02VzrzyOZJ5xIJ3UFIenKkUkGg8GjgWQ==,
-      }
+    resolution: {integrity: sha512-YZ9hP4O0X9PQb8eO980qmLNGH4zT3I9+SZTdt0Pr0YyuGQhYKoOZkV02VzrzyOZJ5xIJ3UFIenKkUkGg8GjgWQ==}
     cpu: [arm64]
     os: [openharmony]
 
   '@unrs/resolver-binding-wasm32-wasi@1.12.2':
-    resolution:
-      {
-        integrity: sha512-tYFDIkMxSflfEc/h92ZWNsZlHSwgimbNHSO3PL2JWQHfCuC2q316jMyYU9TIWZsFK2bQwyK5VAdYgn8ygPj69A==,
-      }
-    engines: { node: '>=14.0.0' }
+    resolution: {integrity: sha512-tYFDIkMxSflfEc/h92ZWNsZlHSwgimbNHSO3PL2JWQHfCuC2q316jMyYU9TIWZsFK2bQwyK5VAdYgn8ygPj69A==}
+    engines: {node: '>=14.0.0'}
     cpu: [wasm32]
 
   '@unrs/resolver-binding-win32-arm64-msvc@1.12.2':
-    resolution:
-      {
-        integrity: sha512-qzNyg3xL0VPQmCaUh+N5jSitce6k+uCBfMDesWRnlULOZaqUkaJ0ybdT+UqlAWJoQjuqfIU/0Ptx9bteN4D82g==,
-      }
+    resolution: {integrity: sha512-qzNyg3xL0VPQmCaUh+N5jSitce6k+uCBfMDesWRnlULOZaqUkaJ0ybdT+UqlAWJoQjuqfIU/0Ptx9bteN4D82g==}
     cpu: [arm64]
     os: [win32]
 
   '@unrs/resolver-binding-win32-ia32-msvc@1.12.2':
-    resolution:
-      {
-        integrity: sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==,
-      }
+    resolution: {integrity: sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==}
     cpu: [ia32]
     os: [win32]
 
   '@unrs/resolver-binding-win32-x64-msvc@1.12.2':
-    resolution:
-      {
-        integrity: sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==,
-      }
+    resolution: {integrity: sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==}
     cpu: [x64]
     os: [win32]
 
   '@vitejs/plugin-react@4.7.0':
-    resolution:
-      {
-        integrity: sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==,
-      }
-    engines: { node: ^14.18.0 || >=16.0.0 }
+    resolution: {integrity: sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
     peerDependencies:
       vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0
 
   '@yarnpkg/lockfile@1.1.0':
-    resolution:
-      {
-        integrity: sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==,
-      }
+    resolution: {integrity: sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==}
 
   '@yarnpkg/parsers@3.0.2':
-    resolution:
-      {
-        integrity: sha512-/HcYgtUSiJiot/XWGLOlGxPYUG65+/31V8oqk17vZLW1xlCoR4PampyePljOxY2n8/3jz9+tIFzICsyGujJZoA==,
-      }
-    engines: { node: '>=18.12.0' }
+    resolution: {integrity: sha512-/HcYgtUSiJiot/XWGLOlGxPYUG65+/31V8oqk17vZLW1xlCoR4PampyePljOxY2n8/3jz9+tIFzICsyGujJZoA==}
+    engines: {node: '>=18.12.0'}
 
   '@zkochan/js-yaml@0.0.7':
-    resolution:
-      {
-        integrity: sha512-nrUSn7hzt7J6JWgWGz78ZYI8wj+gdIJdk0Ynjpp8l+trkn58Uqsf6RYrYkEK+3X18EX+TNdtJI0WxAtc+L84SQ==,
-      }
+    resolution: {integrity: sha512-nrUSn7hzt7J6JWgWGz78ZYI8wj+gdIJdk0Ynjpp8l+trkn58Uqsf6RYrYkEK+3X18EX+TNdtJI0WxAtc+L84SQ==}
     hasBin: true
 
   JSONStream@1.3.5:
-    resolution:
-      {
-        integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==,
-      }
+    resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==}
     hasBin: true
 
   abbrev@2.0.0:
-    resolution:
-      {
-        integrity: sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   accept-language-parser@1.5.0:
-    resolution:
-      {
-        integrity: sha512-QhyTbMLYo0BBGg1aWbeMG4ekWtds/31BrEU+DONOg/7ax23vxpL03Pb7/zBmha2v7vdD3AyzZVWBVGEZxKOXWw==,
-      }
+    resolution: {integrity: sha512-QhyTbMLYo0BBGg1aWbeMG4ekWtds/31BrEU+DONOg/7ax23vxpL03Pb7/zBmha2v7vdD3AyzZVWBVGEZxKOXWw==}
 
   accepts@2.0.0:
-    resolution:
-      {
-        integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==}
+    engines: {node: '>= 0.6'}
 
   acorn-jsx@5.3.2:
-    resolution:
-      {
-        integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==,
-      }
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
       acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
 
   acorn-walk@8.3.4:
-    resolution:
-      {
-        integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==,
-      }
-    engines: { node: '>=0.4.0' }
+    resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==}
+    engines: {node: '>=0.4.0'}
 
   acorn@8.15.0:
-    resolution:
-      {
-        integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==,
-      }
-    engines: { node: '>=0.4.0' }
+    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
+    engines: {node: '>=0.4.0'}
     hasBin: true
 
   add-stream@1.0.0:
-    resolution:
-      {
-        integrity: sha512-qQLMr+8o0WC4FZGQTcJiKBVC59JylcPSrTtk6usvmIDFUOCKegapy1VHQwRbFMOFyb/inzUVqHs+eMYKDM1YeQ==,
-      }
+    resolution: {integrity: sha512-qQLMr+8o0WC4FZGQTcJiKBVC59JylcPSrTtk6usvmIDFUOCKegapy1VHQwRbFMOFyb/inzUVqHs+eMYKDM1YeQ==}
 
   agent-base@7.1.4:
-    resolution:
-      {
-        integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==,
-      }
-    engines: { node: '>= 14' }
+    resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==}
+    engines: {node: '>= 14'}
 
   aggregate-error@3.1.0:
-    resolution:
-      {
-        integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==}
+    engines: {node: '>=8'}
 
   ajv@6.12.6:
-    resolution:
-      {
-        integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==,
-      }
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
 
   ajv@8.20.0:
-    resolution:
-      {
-        integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==,
-      }
+    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
 
   ansi-colors@4.1.3:
-    resolution:
-      {
-        integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
+    engines: {node: '>=6'}
 
   ansi-escapes@4.3.2:
-    resolution:
-      {
-        integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
+    engines: {node: '>=8'}
 
   ansi-regex@5.0.1:
-    resolution:
-      {
-        integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
 
   ansi-regex@6.2.2:
-    resolution:
-      {
-        integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
+    engines: {node: '>=12'}
 
   ansi-styles@4.3.0:
-    resolution:
-      {
-        integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
 
   ansi-styles@5.2.0:
-    resolution:
-      {
-        integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==}
+    engines: {node: '>=10'}
 
   ansi-styles@6.2.3:
-    resolution:
-      {
-        integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
+    engines: {node: '>=12'}
 
   anymatch@3.1.3:
-    resolution:
-      {
-        integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
+    engines: {node: '>= 8'}
 
   appstash@0.7.0:
-    resolution:
-      {
-        integrity: sha512-UExc8kEseReJRbllAkQ/qeW+jHb4iVFR8bLfggSLvSO7LwiVjQWfnQxN+ToLkVBKqMbIENrLUTvynMSEC73xUg==,
-      }
+    resolution: {integrity: sha512-UExc8kEseReJRbllAkQ/qeW+jHb4iVFR8bLfggSLvSO7LwiVjQWfnQxN+ToLkVBKqMbIENrLUTvynMSEC73xUg==}
 
   aproba@2.0.0:
-    resolution:
-      {
-        integrity: sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==,
-      }
+    resolution: {integrity: sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==}
 
   arg@4.1.3:
-    resolution:
-      {
-        integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==,
-      }
+    resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
 
   argparse@1.0.10:
-    resolution:
-      {
-        integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==,
-      }
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
 
   argparse@2.0.1:
-    resolution:
-      {
-        integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==,
-      }
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
 
   aria-hidden@1.2.6:
-    resolution:
-      {
-        integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
+    engines: {node: '>=10'}
 
   aria-query@4.2.2:
-    resolution:
-      {
-        integrity: sha512-o/HelwhuKpTj/frsOsbNLNgnNGVIFsVP/SW2BSF14gVl7kAfMOJ6/8wUAUvG1R1NHKrfG+2sHZTu0yauT1qBrA==,
-      }
-    engines: { node: '>=6.0' }
+    resolution: {integrity: sha512-o/HelwhuKpTj/frsOsbNLNgnNGVIFsVP/SW2BSF14gVl7kAfMOJ6/8wUAUvG1R1NHKrfG+2sHZTu0yauT1qBrA==}
+    engines: {node: '>=6.0'}
 
   aria-query@5.3.0:
-    resolution:
-      {
-        integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==,
-      }
+    resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==}
 
   array-differ@3.0.0:
-    resolution:
-      {
-        integrity: sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==}
+    engines: {node: '>=8'}
 
   array-ify@1.0.0:
-    resolution:
-      {
-        integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==,
-      }
+    resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==}
 
   array-union@2.1.0:
-    resolution:
-      {
-        integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
+    engines: {node: '>=8'}
 
   arrify@1.0.1:
-    resolution:
-      {
-        integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==}
+    engines: {node: '>=0.10.0'}
 
   arrify@2.0.1:
-    resolution:
-      {
-        integrity: sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==}
+    engines: {node: '>=8'}
 
   asap@2.0.6:
-    resolution:
-      {
-        integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==,
-      }
+    resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==}
 
   async-retry@1.3.3:
-    resolution:
-      {
-        integrity: sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==,
-      }
+    resolution: {integrity: sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==}
 
   async@3.2.6:
-    resolution:
-      {
-        integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==,
-      }
+    resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==}
 
   asynckit@0.4.0:
-    resolution:
-      {
-        integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==,
-      }
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
   atob@2.1.2:
-    resolution:
-      {
-        integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==,
-      }
-    engines: { node: '>= 4.5.0' }
+    resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
+    engines: {node: '>= 4.5.0'}
     hasBin: true
 
   axios@1.13.2:
-    resolution:
-      {
-        integrity: sha512-VPk9ebNqPcy5lRGuSlKx752IlDatOjT9paPlm8A7yOuW2Fbvp4X3JznJtT4f0GzGLLiWE9W8onz51SqLYwzGaA==,
-      }
+    resolution: {integrity: sha512-VPk9ebNqPcy5lRGuSlKx752IlDatOjT9paPlm8A7yOuW2Fbvp4X3JznJtT4f0GzGLLiWE9W8onz51SqLYwzGaA==}
 
   babel-jest@30.4.1:
-    resolution:
-      {
-        integrity: sha512-fATAbM8piYxkiXQp3RBXmZHxZVNJZAVXXfyeyCN2Tida3+qJ8ea9UxhiJ2y4fLO90ZImKt6k9FlcH2+rLkJGhw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-fATAbM8piYxkiXQp3RBXmZHxZVNJZAVXXfyeyCN2Tida3+qJ8ea9UxhiJ2y4fLO90ZImKt6k9FlcH2+rLkJGhw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       '@babel/core': ^7.11.0 || ^8.0.0-0
 
   babel-plugin-istanbul@7.0.1:
-    resolution:
-      {
-        integrity: sha512-D8Z6Qm8jCvVXtIRkBnqNHX0zJ37rQcFJ9u8WOS6tkYOsRdHBzypCstaxWiu5ZIlqQtviRYbgnRLSoCEvjqcqbA==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-D8Z6Qm8jCvVXtIRkBnqNHX0zJ37rQcFJ9u8WOS6tkYOsRdHBzypCstaxWiu5ZIlqQtviRYbgnRLSoCEvjqcqbA==}
+    engines: {node: '>=12'}
 
   babel-plugin-jest-hoist@30.4.0:
-    resolution:
-      {
-        integrity: sha512-9EdtWM/sSfXLOGLwSn+GS6pIXyBnL07/8gyJlwFXjWy4DxMOyItqyUT29d4lQiS380EZwYlX7/At4PgBS+m2aA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-9EdtWM/sSfXLOGLwSn+GS6pIXyBnL07/8gyJlwFXjWy4DxMOyItqyUT29d4lQiS380EZwYlX7/At4PgBS+m2aA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   babel-plugin-styled-components@2.1.4:
-    resolution:
-      {
-        integrity: sha512-Xgp9g+A/cG47sUyRwwYxGM4bR/jDRg5N6it/8+HxCnbT5XNKSKDT9xm4oag/osgqjC2It/vH0yXsomOG6k558g==,
-      }
+    resolution: {integrity: sha512-Xgp9g+A/cG47sUyRwwYxGM4bR/jDRg5N6it/8+HxCnbT5XNKSKDT9xm4oag/osgqjC2It/vH0yXsomOG6k558g==}
     peerDependencies:
       styled-components: '>= 2'
 
   babel-preset-current-node-syntax@1.2.0:
-    resolution:
-      {
-        integrity: sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==,
-      }
+    resolution: {integrity: sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==}
     peerDependencies:
       '@babel/core': ^7.0.0 || ^8.0.0-0
 
   babel-preset-jest@30.4.0:
-    resolution:
-      {
-        integrity: sha512-lBY4jxsNmCnSiu7kquw8ZC9F4+XLMOKypT3RnNHPvU2Kpd4W0xaPuLr5ZkRyOsvLYAY4yaW1ZwTW4xB7NIiZzg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-lBY4jxsNmCnSiu7kquw8ZC9F4+XLMOKypT3RnNHPvU2Kpd4W0xaPuLr5ZkRyOsvLYAY4yaW1ZwTW4xB7NIiZzg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       '@babel/core': ^7.11.0 || ^8.0.0-beta.1
 
   babel-runtime@6.25.0:
-    resolution:
-      {
-        integrity: sha512-zeCYxDePWYAT/DfmQWIHsMSFW2vv45UIwIAMjGvQVsTd47RwsiRH0uK1yzyWZ7LDBKdhnGDPM6NYEO5CZyhPrg==,
-      }
+    resolution: {integrity: sha512-zeCYxDePWYAT/DfmQWIHsMSFW2vv45UIwIAMjGvQVsTd47RwsiRH0uK1yzyWZ7LDBKdhnGDPM6NYEO5CZyhPrg==}
 
   balanced-match@1.0.2:
-    resolution:
-      {
-        integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==,
-      }
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
   balanced-match@4.0.4:
-    resolution:
-      {
-        integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==,
-      }
-    engines: { node: 18 || 20 || >=22 }
+    resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
+    engines: {node: 18 || 20 || >=22}
 
   base-64@1.0.0:
-    resolution:
-      {
-        integrity: sha512-kwDPIFCGx0NZHog36dj+tHiwP4QMzsZ3AgMViUBKI0+V5n4U0ufTCUMhnQ04diaRI8EX/QcPfql7zlhZ7j4zgg==,
-      }
+    resolution: {integrity: sha512-kwDPIFCGx0NZHog36dj+tHiwP4QMzsZ3AgMViUBKI0+V5n4U0ufTCUMhnQ04diaRI8EX/QcPfql7zlhZ7j4zgg==}
 
   base64-js@1.5.1:
-    resolution:
-      {
-        integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==,
-      }
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
   baseline-browser-mapping@2.9.15:
-    resolution:
-      {
-        integrity: sha512-kX8h7K2srmDyYnXRIppo4AH/wYgzWVCs+eKr3RusRSQ5PvRYoEFmR/I0PbdTjKFAoKqp5+kbxnNTFO9jOfSVJg==,
-      }
+    resolution: {integrity: sha512-kX8h7K2srmDyYnXRIppo4AH/wYgzWVCs+eKr3RusRSQ5PvRYoEFmR/I0PbdTjKFAoKqp5+kbxnNTFO9jOfSVJg==}
     hasBin: true
 
   before-after-hook@2.2.3:
-    resolution:
-      {
-        integrity: sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==,
-      }
+    resolution: {integrity: sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==}
 
   big-integer@1.6.52:
-    resolution:
-      {
-        integrity: sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==,
-      }
-    engines: { node: '>=0.6' }
+    resolution: {integrity: sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==}
+    engines: {node: '>=0.6'}
 
   bin-links@4.0.4:
-    resolution:
-      {
-        integrity: sha512-cMtq4W5ZsEwcutJrVId+a/tjt8GSbS+h0oNkdl6+6rBuEv8Ot33Bevj5KPm40t309zuhVic8NjpuL42QCiJWWA==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-cMtq4W5ZsEwcutJrVId+a/tjt8GSbS+h0oNkdl6+6rBuEv8Ot33Bevj5KPm40t309zuhVic8NjpuL42QCiJWWA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   binary-extensions@2.3.0:
-    resolution:
-      {
-        integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
+    engines: {node: '>=8'}
 
   bl@4.1.0:
-    resolution:
-      {
-        integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==,
-      }
+    resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
 
   body-parser@2.2.1:
-    resolution:
-      {
-        integrity: sha512-nfDwkulwiZYQIGwxdy0RUmowMhKcFVcYXUU7m4QlKYim1rUtg83xm2yjZ40QjDuc291AJjjeSc9b++AWHSgSHw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-nfDwkulwiZYQIGwxdy0RUmowMhKcFVcYXUU7m4QlKYim1rUtg83xm2yjZ40QjDuc291AJjjeSc9b++AWHSgSHw==}
+    engines: {node: '>=18'}
 
   boolbase@1.0.0:
-    resolution:
-      {
-        integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==,
-      }
+    resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
 
   bowser@2.14.1:
-    resolution:
-      {
-        integrity: sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==,
-      }
+    resolution: {integrity: sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==}
 
   brace-expansion@1.1.12:
-    resolution:
-      {
-        integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==,
-      }
+    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
 
   brace-expansion@2.0.2:
-    resolution:
-      {
-        integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==,
-      }
+    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
 
   brace-expansion@2.1.0:
-    resolution:
-      {
-        integrity: sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==,
-      }
+    resolution: {integrity: sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==}
 
   brace-expansion@5.0.4:
-    resolution:
-      {
-        integrity: sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==,
-      }
-    engines: { node: 18 || 20 || >=22 }
+    resolution: {integrity: sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==}
+    engines: {node: 18 || 20 || >=22}
 
   brace-expansion@5.0.6:
-    resolution:
-      {
-        integrity: sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==,
-      }
-    engines: { node: 18 || 20 || >=22 }
+    resolution: {integrity: sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==}
+    engines: {node: 18 || 20 || >=22}
 
   braces@3.0.3:
-    resolution:
-      {
-        integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
 
   broadcast-channel@3.7.0:
-    resolution:
-      {
-        integrity: sha512-cIAKJXAxGJceNZGTZSBzMxzyOn72cVgPnKx4dc6LRjQgbaJUQqhy5rzL3zbMxkMWsGKkv2hSFkPRMEXfoMZ2Mg==,
-      }
+    resolution: {integrity: sha512-cIAKJXAxGJceNZGTZSBzMxzyOn72cVgPnKx4dc6LRjQgbaJUQqhy5rzL3zbMxkMWsGKkv2hSFkPRMEXfoMZ2Mg==}
 
   browserslist@4.28.1:
-    resolution:
-      {
-        integrity: sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==,
-      }
-    engines: { node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7 }
+    resolution: {integrity: sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
 
   bs-logger@0.2.6:
-    resolution:
-      {
-        integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==}
+    engines: {node: '>= 6'}
 
   bser@2.1.1:
-    resolution:
-      {
-        integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==,
-      }
+    resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}
 
   buffer-equal-constant-time@1.0.1:
-    resolution:
-      {
-        integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==,
-      }
+    resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
 
   buffer-from@1.1.2:
-    resolution:
-      {
-        integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==,
-      }
+    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
 
   buffer@5.6.0:
-    resolution:
-      {
-        integrity: sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw==,
-      }
+    resolution: {integrity: sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw==}
 
   buffer@5.7.1:
-    resolution:
-      {
-        integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==,
-      }
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
 
   busboy@0.3.1:
-    resolution:
-      {
-        integrity: sha512-y7tTxhGKXcyBxRKAni+awqx8uqaJKrSFSNFSeRG5CsWNdmy2BIK+6VGWEW7TZnIO/533mtMEA4rOevQV815YJw==,
-      }
-    engines: { node: '>=4.5.0' }
+    resolution: {integrity: sha512-y7tTxhGKXcyBxRKAni+awqx8uqaJKrSFSNFSeRG5CsWNdmy2BIK+6VGWEW7TZnIO/533mtMEA4rOevQV815YJw==}
+    engines: {node: '>=4.5.0'}
 
   byte-size@8.1.1:
-    resolution:
-      {
-        integrity: sha512-tUkzZWK0M/qdoLEqikxBWe4kumyuwjl3HO6zHTr4yEI23EojPtLYXdG1+AQY7MN0cGyNDvEaJ8wiYQm6P2bPxg==,
-      }
-    engines: { node: '>=12.17' }
+    resolution: {integrity: sha512-tUkzZWK0M/qdoLEqikxBWe4kumyuwjl3HO6zHTr4yEI23EojPtLYXdG1+AQY7MN0cGyNDvEaJ8wiYQm6P2bPxg==}
+    engines: {node: '>=12.17'}
 
   bytes@3.1.2:
-    resolution:
-      {
-        integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
+    engines: {node: '>= 0.8'}
 
   cacache@18.0.4:
-    resolution:
-      {
-        integrity: sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   call-bind-apply-helpers@1.0.2:
-    resolution:
-      {
-        integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
 
   call-bound@1.0.4:
-    resolution:
-      {
-        integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
 
   callsites@3.1.0:
-    resolution:
-      {
-        integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
 
   camel-case@3.0.0:
-    resolution:
-      {
-        integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==,
-      }
+    resolution: {integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==}
 
   camelcase-keys@6.2.2:
-    resolution:
-      {
-        integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==}
+    engines: {node: '>=8'}
 
   camelcase@5.3.1:
-    resolution:
-      {
-        integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
+    engines: {node: '>=6'}
 
   camelcase@6.3.0:
-    resolution:
-      {
-        integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
+    engines: {node: '>=10'}
 
   camelize@1.0.1:
-    resolution:
-      {
-        integrity: sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ==,
-      }
+    resolution: {integrity: sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ==}
 
   caniuse-lite@1.0.30001765:
-    resolution:
-      {
-        integrity: sha512-LWcNtSyZrakjECqmpP4qdg0MMGdN368D7X8XvvAqOcqMv0RxnlqVKZl2V6/mBR68oYMxOZPLw/gO7DuisMHUvQ==,
-      }
+    resolution: {integrity: sha512-LWcNtSyZrakjECqmpP4qdg0MMGdN368D7X8XvvAqOcqMv0RxnlqVKZl2V6/mBR68oYMxOZPLw/gO7DuisMHUvQ==}
 
   case@1.6.3:
-    resolution:
-      {
-        integrity: sha512-mzDSXIPaFwVDvZAHqZ9VlbyF4yyXRuX6IvB06WvPYkqJVO24kX1PPhv9bfpKNFZyxYFmmgo03HUiD8iklmJYRQ==,
-      }
-    engines: { node: '>= 0.8.0' }
+    resolution: {integrity: sha512-mzDSXIPaFwVDvZAHqZ9VlbyF4yyXRuX6IvB06WvPYkqJVO24kX1PPhv9bfpKNFZyxYFmmgo03HUiD8iklmJYRQ==}
+    engines: {node: '>= 0.8.0'}
 
   chalk@3.0.0:
-    resolution:
-      {
-        integrity: sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==}
+    engines: {node: '>=8'}
 
   chalk@4.1.0:
-    resolution:
-      {
-        integrity: sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==}
+    engines: {node: '>=10'}
 
   chalk@4.1.2:
-    resolution:
-      {
-        integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
 
   char-regex@1.0.2:
-    resolution:
-      {
-        integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==}
+    engines: {node: '>=10'}
 
   chardet@2.1.1:
-    resolution:
-      {
-        integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==,
-      }
+    resolution: {integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==}
 
   cheerio-select@2.1.0:
-    resolution:
-      {
-        integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==,
-      }
+    resolution: {integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==}
 
   cheerio@1.0.0-rc.3:
-    resolution:
-      {
-        integrity: sha512-0td5ijfUPuubwLUu0OBoe98gZj8C/AA+RW3v67GPlGOrvxWjZmBXiBCRU+I8VEiNyJzjth40POfHiz2RB3gImA==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-0td5ijfUPuubwLUu0OBoe98gZj8C/AA+RW3v67GPlGOrvxWjZmBXiBCRU+I8VEiNyJzjth40POfHiz2RB3gImA==}
+    engines: {node: '>= 0.6'}
 
   cheerio@1.1.2:
-    resolution:
-      {
-        integrity: sha512-IkxPpb5rS/d1IiLbHMgfPuS0FgiWTtFIm/Nj+2woXDLTZ7fOT2eqzgYbdMlLweqlHbsZjxEChoVK+7iph7jyQg==,
-      }
-    engines: { node: '>=20.18.1' }
+    resolution: {integrity: sha512-IkxPpb5rS/d1IiLbHMgfPuS0FgiWTtFIm/Nj+2woXDLTZ7fOT2eqzgYbdMlLweqlHbsZjxEChoVK+7iph7jyQg==}
+    engines: {node: '>=20.18.1'}
 
   chokidar@3.6.0:
-    resolution:
-      {
-        integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==,
-      }
-    engines: { node: '>= 8.10.0' }
+    resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
+    engines: {node: '>= 8.10.0'}
 
   chownr@2.0.0:
-    resolution:
-      {
-        integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
+    engines: {node: '>=10'}
 
   ci-info@3.9.0:
-    resolution:
-      {
-        integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
+    engines: {node: '>=8'}
 
   ci-info@4.3.1:
-    resolution:
-      {
-        integrity: sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==}
+    engines: {node: '>=8'}
 
   ci-info@4.4.0:
-    resolution:
-      {
-        integrity: sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==}
+    engines: {node: '>=8'}
 
   cjs-module-lexer@2.2.0:
-    resolution:
-      {
-        integrity: sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ==,
-      }
+    resolution: {integrity: sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ==}
 
   clean-ansi@0.2.1:
-    resolution:
-      {
-        integrity: sha512-V9IOKBKHv0Sqay4efImuCVWwO8kVmaKU66cvbDBa99F21j2G3ye3mrKkPSfZ7RTR7yP4CNDjtESkNY5dFq+8Sg==,
-      }
+    resolution: {integrity: sha512-V9IOKBKHv0Sqay4efImuCVWwO8kVmaKU66cvbDBa99F21j2G3ye3mrKkPSfZ7RTR7yP4CNDjtESkNY5dFq+8Sg==}
 
   clean-css@4.2.4:
-    resolution:
-      {
-        integrity: sha512-EJUDT7nDVFDvaQgAo2G/PJvxmp1o/c6iXLbswsBbUFXi1Nr+AjA2cKmfbKDMjMvzEe75g3P6JkaDDAKk96A85A==,
-      }
-    engines: { node: '>= 4.0' }
+    resolution: {integrity: sha512-EJUDT7nDVFDvaQgAo2G/PJvxmp1o/c6iXLbswsBbUFXi1Nr+AjA2cKmfbKDMjMvzEe75g3P6JkaDDAKk96A85A==}
+    engines: {node: '>= 4.0'}
 
   clean-stack@2.2.0:
-    resolution:
-      {
-        integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==}
+    engines: {node: '>=6'}
 
   cli-cursor@3.1.0:
-    resolution:
-      {
-        integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==}
+    engines: {node: '>=8'}
 
   cli-spinners@2.6.1:
-    resolution:
-      {
-        integrity: sha512-x/5fWmGMnbKQAaNwN+UZlV79qBLM9JFnJuJ03gIi5whrob0xV0ofNVHy9DhwGdsMJQc2OKv0oGmLzvaqvAVv+g==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-x/5fWmGMnbKQAaNwN+UZlV79qBLM9JFnJuJ03gIi5whrob0xV0ofNVHy9DhwGdsMJQc2OKv0oGmLzvaqvAVv+g==}
+    engines: {node: '>=6'}
 
   cli-spinners@2.9.2:
-    resolution:
-      {
-        integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==}
+    engines: {node: '>=6'}
 
   cli-width@3.0.0:
-    resolution:
-      {
-        integrity: sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==}
+    engines: {node: '>= 10'}
 
   cliui@6.0.0:
-    resolution:
-      {
-        integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==,
-      }
+    resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==}
 
   cliui@7.0.4:
-    resolution:
-      {
-        integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==,
-      }
+    resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
 
   cliui@8.0.1:
-    resolution:
-      {
-        integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==}
+    engines: {node: '>=12'}
 
   clone-deep@4.0.1:
-    resolution:
-      {
-        integrity: sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==}
+    engines: {node: '>=6'}
 
   clone@1.0.4:
-    resolution:
-      {
-        integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==,
-      }
-    engines: { node: '>=0.8' }
+    resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
+    engines: {node: '>=0.8'}
 
   clsx@1.2.1:
-    resolution:
-      {
-        integrity: sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==}
+    engines: {node: '>=6'}
 
   clsx@2.1.1:
-    resolution:
-      {
-        integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
+    engines: {node: '>=6'}
 
   cmd-shim@6.0.3:
-    resolution:
-      {
-        integrity: sha512-FMabTRlc5t5zjdenF6mS0MBeFZm0XqHqeOkcskKFb/LYCcRQ5fVgLOHVc4Lq9CqABd9zhjwPjMBCJvMCziSVtA==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-FMabTRlc5t5zjdenF6mS0MBeFZm0XqHqeOkcskKFb/LYCcRQ5fVgLOHVc4Lq9CqABd9zhjwPjMBCJvMCziSVtA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   co@4.6.0:
-    resolution:
-      {
-        integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==,
-      }
-    engines: { iojs: '>= 1.0.0', node: '>= 0.12.0' }
+    resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==}
+    engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'}
 
   collect-v8-coverage@1.0.3:
-    resolution:
-      {
-        integrity: sha512-1L5aqIkwPfiodaMgQunkF1zRhNqifHBmtbbbxcr6yVxxBnliw4TDOW6NxpO8DJLgJ16OT+Y4ztZqP6p/FtXnAw==,
-      }
+    resolution: {integrity: sha512-1L5aqIkwPfiodaMgQunkF1zRhNqifHBmtbbbxcr6yVxxBnliw4TDOW6NxpO8DJLgJ16OT+Y4ztZqP6p/FtXnAw==}
 
   color-convert@2.0.1:
-    resolution:
-      {
-        integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==,
-      }
-    engines: { node: '>=7.0.0' }
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
 
   color-name@1.1.4:
-    resolution:
-      {
-        integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==,
-      }
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
 
   color-support@1.1.3:
-    resolution:
-      {
-        integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==,
-      }
+    resolution: {integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==}
     hasBin: true
 
   columnify@1.6.0:
-    resolution:
-      {
-        integrity: sha512-lomjuFZKfM6MSAnV9aCZC9sc0qGbmZdfygNv+nCpqVkSKdCxCklLtd16O0EILGkImHw9ZpHkAnHaB+8Zxq5W6Q==,
-      }
-    engines: { node: '>=8.0.0' }
+    resolution: {integrity: sha512-lomjuFZKfM6MSAnV9aCZC9sc0qGbmZdfygNv+nCpqVkSKdCxCklLtd16O0EILGkImHw9ZpHkAnHaB+8Zxq5W6Q==}
+    engines: {node: '>=8.0.0'}
 
   combined-stream@1.0.8:
-    resolution:
-      {
-        integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
 
   commander@10.0.1:
-    resolution:
-      {
-        integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
+    engines: {node: '>=14'}
 
   commander@2.17.1:
-    resolution:
-      {
-        integrity: sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==,
-      }
+    resolution: {integrity: sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==}
 
   commander@2.19.0:
-    resolution:
-      {
-        integrity: sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==,
-      }
+    resolution: {integrity: sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==}
 
   commander@5.1.0:
-    resolution:
-      {
-        integrity: sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==}
+    engines: {node: '>= 6'}
 
   common-ancestor-path@1.0.1:
-    resolution:
-      {
-        integrity: sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==,
-      }
+    resolution: {integrity: sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==}
 
   compare-func@2.0.0:
-    resolution:
-      {
-        integrity: sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==,
-      }
+    resolution: {integrity: sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==}
 
   component-emitter@1.3.1:
-    resolution:
-      {
-        integrity: sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==,
-      }
+    resolution: {integrity: sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==}
 
   concat-map@0.0.1:
-    resolution:
-      {
-        integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==,
-      }
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
 
   concat-stream@2.0.0:
-    resolution:
-      {
-        integrity: sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==,
-      }
-    engines: { '0': node >= 6.0 }
+    resolution: {integrity: sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==}
+    engines: {'0': node >= 6.0}
 
   config-chain@1.1.13:
-    resolution:
-      {
-        integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==,
-      }
+    resolution: {integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==}
 
   console-control-strings@1.1.0:
-    resolution:
-      {
-        integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==,
-      }
+    resolution: {integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==}
 
   content-disposition@1.0.1:
-    resolution:
-      {
-        integrity: sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==}
+    engines: {node: '>=18'}
 
   content-type@1.0.5:
-    resolution:
-      {
-        integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
+    engines: {node: '>= 0.6'}
 
   conventional-changelog-angular@7.0.0:
-    resolution:
-      {
-        integrity: sha512-ROjNchA9LgfNMTTFSIWPzebCwOGFdgkEq45EnvvrmSLvCtAw0HSmrCs7/ty+wAeYUZyNay0YMUNYFTRL72PkBQ==,
-      }
-    engines: { node: '>=16' }
+    resolution: {integrity: sha512-ROjNchA9LgfNMTTFSIWPzebCwOGFdgkEq45EnvvrmSLvCtAw0HSmrCs7/ty+wAeYUZyNay0YMUNYFTRL72PkBQ==}
+    engines: {node: '>=16'}
 
   conventional-changelog-core@5.0.1:
-    resolution:
-      {
-        integrity: sha512-Rvi5pH+LvgsqGwZPZ3Cq/tz4ty7mjijhr3qR4m9IBXNbxGGYgTVVO+duXzz9aArmHxFtwZ+LRkrNIMDQzgoY4A==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-Rvi5pH+LvgsqGwZPZ3Cq/tz4ty7mjijhr3qR4m9IBXNbxGGYgTVVO+duXzz9aArmHxFtwZ+LRkrNIMDQzgoY4A==}
+    engines: {node: '>=14'}
 
   conventional-changelog-preset-loader@3.0.0:
-    resolution:
-      {
-        integrity: sha512-qy9XbdSLmVnwnvzEisjxdDiLA4OmV3o8db+Zdg4WiFw14fP3B6XNz98X0swPPpkTd/pc1K7+adKgEDM1JCUMiA==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-qy9XbdSLmVnwnvzEisjxdDiLA4OmV3o8db+Zdg4WiFw14fP3B6XNz98X0swPPpkTd/pc1K7+adKgEDM1JCUMiA==}
+    engines: {node: '>=14'}
 
   conventional-changelog-writer@6.0.1:
-    resolution:
-      {
-        integrity: sha512-359t9aHorPw+U+nHzUXHS5ZnPBOizRxfQsWT5ZDHBfvfxQOAik+yfuhKXG66CN5LEWPpMNnIMHUTCKeYNprvHQ==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-359t9aHorPw+U+nHzUXHS5ZnPBOizRxfQsWT5ZDHBfvfxQOAik+yfuhKXG66CN5LEWPpMNnIMHUTCKeYNprvHQ==}
+    engines: {node: '>=14'}
     hasBin: true
 
   conventional-commits-filter@3.0.0:
-    resolution:
-      {
-        integrity: sha512-1ymej8b5LouPx9Ox0Dw/qAO2dVdfpRFq28e5Y0jJEU8ZrLdy0vOSkkIInwmxErFGhg6SALro60ZrwYFVTUDo4Q==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-1ymej8b5LouPx9Ox0Dw/qAO2dVdfpRFq28e5Y0jJEU8ZrLdy0vOSkkIInwmxErFGhg6SALro60ZrwYFVTUDo4Q==}
+    engines: {node: '>=14'}
 
   conventional-commits-parser@4.0.0:
-    resolution:
-      {
-        integrity: sha512-WRv5j1FsVM5FISJkoYMR6tPk07fkKT0UodruX4je86V4owk451yjXAKzKAPOs9l7y59E2viHUS9eQ+dfUA9NSg==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-WRv5j1FsVM5FISJkoYMR6tPk07fkKT0UodruX4je86V4owk451yjXAKzKAPOs9l7y59E2viHUS9eQ+dfUA9NSg==}
+    engines: {node: '>=14'}
     hasBin: true
 
   conventional-recommended-bump@7.0.1:
-    resolution:
-      {
-        integrity: sha512-Ft79FF4SlOFvX4PkwFDRnaNiIVX7YbmqGU0RwccUaiGvgp3S0a8ipR2/Qxk31vclDNM+GSdJOVs2KrsUCjblVA==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-Ft79FF4SlOFvX4PkwFDRnaNiIVX7YbmqGU0RwccUaiGvgp3S0a8ipR2/Qxk31vclDNM+GSdJOVs2KrsUCjblVA==}
+    engines: {node: '>=14'}
     hasBin: true
 
   convert-source-map@2.0.0:
-    resolution:
-      {
-        integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==,
-      }
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
 
   cookie-parser@1.4.7:
-    resolution:
-      {
-        integrity: sha512-nGUvgXnotP3BsjiLX2ypbQnWoGUPIIfHQNZkkC668ntrzGWEZVW70HDEB1qnNGMicPje6EttlIgzo51YSwNQGw==,
-      }
-    engines: { node: '>= 0.8.0' }
+    resolution: {integrity: sha512-nGUvgXnotP3BsjiLX2ypbQnWoGUPIIfHQNZkkC668ntrzGWEZVW70HDEB1qnNGMicPje6EttlIgzo51YSwNQGw==}
+    engines: {node: '>= 0.8.0'}
 
   cookie-signature@1.0.6:
-    resolution:
-      {
-        integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==,
-      }
+    resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==}
 
   cookie-signature@1.2.2:
-    resolution:
-      {
-        integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==,
-      }
-    engines: { node: '>=6.6.0' }
+    resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==}
+    engines: {node: '>=6.6.0'}
 
   cookie@0.7.2:
-    resolution:
-      {
-        integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}
+    engines: {node: '>= 0.6'}
 
   cookiejar@2.1.4:
-    resolution:
-      {
-        integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==,
-      }
+    resolution: {integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==}
 
   copyfiles@2.4.1:
-    resolution:
-      {
-        integrity: sha512-fereAvAvxDrQDOXybk3Qu3dPbOoKoysFMWtkY3mv5BsL8//OSZVL5DCLYqgRfY5cWirgRzlC+WSrxp6Bo3eNZg==,
-      }
+    resolution: {integrity: sha512-fereAvAvxDrQDOXybk3Qu3dPbOoKoysFMWtkY3mv5BsL8//OSZVL5DCLYqgRfY5cWirgRzlC+WSrxp6Bo3eNZg==}
     hasBin: true
 
   core-js-pure@3.47.0:
-    resolution:
-      {
-        integrity: sha512-BcxeDbzUrRnXGYIVAGFtcGQVNpFcUhVjr6W7F8XktvQW2iJP9e66GP6xdKotCRFlrxBvNIBrhwKteRXqMV86Nw==,
-      }
+    resolution: {integrity: sha512-BcxeDbzUrRnXGYIVAGFtcGQVNpFcUhVjr6W7F8XktvQW2iJP9e66GP6xdKotCRFlrxBvNIBrhwKteRXqMV86Nw==}
 
   core-js@2.6.12:
-    resolution:
-      {
-        integrity: sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==,
-      }
+    resolution: {integrity: sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==}
     deprecated: core-js@<3.23.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Some versions have web compatibility issues. Please, upgrade your dependencies to the actual version of core-js.
 
   core-util-is@1.0.3:
-    resolution:
-      {
-        integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==,
-      }
+    resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
 
   cors@2.8.6:
-    resolution:
-      {
-        integrity: sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==,
-      }
-    engines: { node: '>= 0.10' }
+    resolution: {integrity: sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==}
+    engines: {node: '>= 0.10'}
 
   cosmiconfig@9.0.0:
-    resolution:
-      {
-        integrity: sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==}
+    engines: {node: '>=14'}
     peerDependencies:
       typescript: '>=4.9.5'
     peerDependenciesMeta:
@@ -8868,142 +6846,79 @@ packages:
         optional: true
 
   create-require@1.1.1:
-    resolution:
-      {
-        integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==,
-      }
+    resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
 
   cron-parser@4.9.0:
-    resolution:
-      {
-        integrity: sha512-p0SaNjrHOnQeR8/VnfGbmg9te2kfyYSQ7Sc/j/6DtPL3JQvKxmjO9TSjNFpujqV3vEYYBvNNvXSxzyksBWAx1Q==,
-      }
-    engines: { node: '>=12.0.0' }
+    resolution: {integrity: sha512-p0SaNjrHOnQeR8/VnfGbmg9te2kfyYSQ7Sc/j/6DtPL3JQvKxmjO9TSjNFpujqV3vEYYBvNNvXSxzyksBWAx1Q==}
+    engines: {node: '>=12.0.0'}
 
   cross-spawn@7.0.6:
-    resolution:
-      {
-        integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
 
   css-color-keywords@1.0.0:
-    resolution:
-      {
-        integrity: sha512-FyyrDHZKEjXDpNJYvVsV960FiqQyXc/LlYmsxl2BcdMb2WPx0OGRVgTg55rPSyLSNMqP52R9r8geSp7apN3Ofg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-FyyrDHZKEjXDpNJYvVsV960FiqQyXc/LlYmsxl2BcdMb2WPx0OGRVgTg55rPSyLSNMqP52R9r8geSp7apN3Ofg==}
+    engines: {node: '>=4'}
 
   css-select@1.2.0:
-    resolution:
-      {
-        integrity: sha512-dUQOBoqdR7QwV90WysXPLXG5LO7nhYBgiWVfxF80DKPF8zx1t/pUd2FYy73emg3zrjtM6dzmYgbHKfV2rxiHQA==,
-      }
+    resolution: {integrity: sha512-dUQOBoqdR7QwV90WysXPLXG5LO7nhYBgiWVfxF80DKPF8zx1t/pUd2FYy73emg3zrjtM6dzmYgbHKfV2rxiHQA==}
 
   css-select@5.2.2:
-    resolution:
-      {
-        integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==,
-      }
+    resolution: {integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==}
 
   css-to-react-native@3.2.0:
-    resolution:
-      {
-        integrity: sha512-e8RKaLXMOFii+02mOlqwjbD00KSEKqblnpO9e++1aXS1fPQOpS1YoqdVHBqPjHNoxeF2mimzVqawm2KCbEdtHQ==,
-      }
+    resolution: {integrity: sha512-e8RKaLXMOFii+02mOlqwjbD00KSEKqblnpO9e++1aXS1fPQOpS1YoqdVHBqPjHNoxeF2mimzVqawm2KCbEdtHQ==}
 
   css-what@2.1.3:
-    resolution:
-      {
-        integrity: sha512-a+EPoD+uZiNfh+5fxw2nO9QwFa6nJe2Or35fGY6Ipw1R3R4AGz1d1TEZrCegvw2YTmZ0jXirGYlzxxpYSHwpEg==,
-      }
+    resolution: {integrity: sha512-a+EPoD+uZiNfh+5fxw2nO9QwFa6nJe2Or35fGY6Ipw1R3R4AGz1d1TEZrCegvw2YTmZ0jXirGYlzxxpYSHwpEg==}
 
   css-what@6.2.2:
-    resolution:
-      {
-        integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==}
+    engines: {node: '>= 6'}
 
   css.escape@1.5.1:
-    resolution:
-      {
-        integrity: sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==,
-      }
+    resolution: {integrity: sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==}
 
   css@3.0.0:
-    resolution:
-      {
-        integrity: sha512-DG9pFfwOrzc+hawpmqX/dHYHJG+Bsdb0klhyi1sDneOgGOXy9wQIC8hzyVp1e4NRYDBdxcylvywPkkXCHAzTyQ==,
-      }
+    resolution: {integrity: sha512-DG9pFfwOrzc+hawpmqX/dHYHJG+Bsdb0klhyi1sDneOgGOXy9wQIC8hzyVp1e4NRYDBdxcylvywPkkXCHAzTyQ==}
 
   cssesc@3.0.0:
-    resolution:
-      {
-        integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
     hasBin: true
 
   cssstyle@4.6.0:
-    resolution:
-      {
-        integrity: sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==}
+    engines: {node: '>=18'}
 
   csstype@3.2.3:
-    resolution:
-      {
-        integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==,
-      }
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
 
   csv-parse@6.2.1:
-    resolution:
-      {
-        integrity: sha512-LRLMV+UCyfMokp8Wb411duBf1gaBKJfOfBWU9eHMJ+b+cJYZsNu3AFmjJf3+yPGd59Exz1TsMjaSFyxnYB9+IQ==,
-      }
+    resolution: {integrity: sha512-LRLMV+UCyfMokp8Wb411duBf1gaBKJfOfBWU9eHMJ+b+cJYZsNu3AFmjJf3+yPGd59Exz1TsMjaSFyxnYB9+IQ==}
 
   csv-parser@3.2.1:
-    resolution:
-      {
-        integrity: sha512-v8RPMSglouR9od735SnwSxLBbCJqEPSbgm1R5qfr8yIiMUCEFjox56kRZid0SvgHJEkxeIEu3+a9QS3YRh7CuA==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-v8RPMSglouR9od735SnwSxLBbCJqEPSbgm1R5qfr8yIiMUCEFjox56kRZid0SvgHJEkxeIEu3+a9QS3YRh7CuA==}
+    engines: {node: '>= 10'}
     hasBin: true
 
   dargs@7.0.0:
-    resolution:
-      {
-        integrity: sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==}
+    engines: {node: '>=8'}
 
   data-urls@5.0.0:
-    resolution:
-      {
-        integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==}
+    engines: {node: '>=18'}
 
   dateformat@3.0.3:
-    resolution:
-      {
-        integrity: sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==,
-      }
+    resolution: {integrity: sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==}
 
   debounce-promise@3.1.2:
-    resolution:
-      {
-        integrity: sha512-rZHcgBkbYavBeD9ej6sP56XfG53d51CD4dnaw989YX/nZ/ZJfgRx/9ePKmTNiUiyQvh4mtrMoS3OAWW+yoYtpg==,
-      }
+    resolution: {integrity: sha512-rZHcgBkbYavBeD9ej6sP56XfG53d51CD4dnaw989YX/nZ/ZJfgRx/9ePKmTNiUiyQvh4mtrMoS3OAWW+yoYtpg==}
 
   debug@4.4.3:
-    resolution:
-      {
-        integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==,
-      }
-    engines: { node: '>=6.0' }
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
     peerDependencies:
       supports-color: '*'
     peerDependenciesMeta:
@@ -9011,37 +6926,22 @@ packages:
         optional: true
 
   decamelize-keys@1.1.1:
-    resolution:
-      {
-        integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==}
+    engines: {node: '>=0.10.0'}
 
   decamelize@1.2.0:
-    resolution:
-      {
-        integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==}
+    engines: {node: '>=0.10.0'}
 
   decimal.js@10.6.0:
-    resolution:
-      {
-        integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==,
-      }
+    resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}
 
   decode-uri-component@0.2.2:
-    resolution:
-      {
-        integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==,
-      }
-    engines: { node: '>=0.10' }
+    resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==}
+    engines: {node: '>=0.10'}
 
   dedent@1.5.3:
-    resolution:
-      {
-        integrity: sha512-NHQtfOOW68WD8lgypbLA5oT+Bt0xXJhiYvoR6SmmNXZfpzOGXwdKWmcwG8N7PwVVWV3eF/68nmD9BaJSsTBhyQ==,
-      }
+    resolution: {integrity: sha512-NHQtfOOW68WD8lgypbLA5oT+Bt0xXJhiYvoR6SmmNXZfpzOGXwdKWmcwG8N7PwVVWV3eF/68nmD9BaJSsTBhyQ==}
     peerDependencies:
       babel-plugin-macros: ^3.1.0
     peerDependenciesMeta:
@@ -9049,10 +6949,7 @@ packages:
         optional: true
 
   dedent@1.7.2:
-    resolution:
-      {
-        integrity: sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA==,
-      }
+    resolution: {integrity: sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA==}
     peerDependencies:
       babel-plugin-macros: ^3.1.0
     peerDependenciesMeta:
@@ -9060,237 +6957,129 @@ packages:
         optional: true
 
   deep-is@0.1.4:
-    resolution:
-      {
-        integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==,
-      }
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
   deepmerge@4.3.1:
-    resolution:
-      {
-        integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
+    engines: {node: '>=0.10.0'}
 
   defaults@1.0.4:
-    resolution:
-      {
-        integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==,
-      }
+    resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==}
 
   define-lazy-prop@2.0.0:
-    resolution:
-      {
-        integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
+    engines: {node: '>=8'}
 
   delayed-stream@1.0.0:
-    resolution:
-      {
-        integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==,
-      }
-    engines: { node: '>=0.4.0' }
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
+    engines: {node: '>=0.4.0'}
 
   depd@1.1.2:
-    resolution:
-      {
-        integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==}
+    engines: {node: '>= 0.6'}
 
   depd@2.0.0:
-    resolution:
-      {
-        integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
+    engines: {node: '>= 0.8'}
 
   deprecation@2.3.1:
-    resolution:
-      {
-        integrity: sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==,
-      }
+    resolution: {integrity: sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==}
 
   dequal@2.0.3:
-    resolution:
-      {
-        integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
 
   detect-indent@5.0.0:
-    resolution:
-      {
-        integrity: sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==}
+    engines: {node: '>=4'}
 
   detect-newline@3.1.0:
-    resolution:
-      {
-        integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==}
+    engines: {node: '>=8'}
 
   detect-node-es@1.1.0:
-    resolution:
-      {
-        integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==,
-      }
+    resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==}
 
   detect-node@2.1.0:
-    resolution:
-      {
-        integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==,
-      }
+    resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==}
 
   dezalgo@1.0.4:
-    resolution:
-      {
-        integrity: sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig==,
-      }
+    resolution: {integrity: sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig==}
 
   dicer@0.3.0:
-    resolution:
-      {
-        integrity: sha512-MdceRRWqltEG2dZqO769g27N/3PXfcKl04VhYnBlo2YhH7zPi88VebsjTKclaOyiuMaGU72hTfw3VkUitGcVCA==,
-      }
-    engines: { node: '>=4.5.0' }
+    resolution: {integrity: sha512-MdceRRWqltEG2dZqO769g27N/3PXfcKl04VhYnBlo2YhH7zPi88VebsjTKclaOyiuMaGU72hTfw3VkUitGcVCA==}
+    engines: {node: '>=4.5.0'}
 
   diff-sequences@29.6.3:
-    resolution:
-      {
-        integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==,
-      }
-    engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 }
+    resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
   diff@4.0.2:
-    resolution:
-      {
-        integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==,
-      }
-    engines: { node: '>=0.3.1' }
+    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
+    engines: {node: '>=0.3.1'}
 
   dom-accessibility-api@0.5.16:
-    resolution:
-      {
-        integrity: sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==,
-      }
+    resolution: {integrity: sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==}
 
   dom-serializer@0.1.1:
-    resolution:
-      {
-        integrity: sha512-l0IU0pPzLWSHBcieZbpOKgkIn3ts3vAh7ZuFyXNwJxJXk/c4Gwj9xaTJwIDVQCXawWD0qb3IzMGH5rglQaO0XA==,
-      }
+    resolution: {integrity: sha512-l0IU0pPzLWSHBcieZbpOKgkIn3ts3vAh7ZuFyXNwJxJXk/c4Gwj9xaTJwIDVQCXawWD0qb3IzMGH5rglQaO0XA==}
 
   dom-serializer@0.2.2:
-    resolution:
-      {
-        integrity: sha512-2/xPb3ORsQ42nHYiSunXkDjPLBaEj/xTwUO4B7XCZQTRk7EBtTOPaygh10YAAh2OI1Qrp6NWfpAhzswj0ydt9g==,
-      }
+    resolution: {integrity: sha512-2/xPb3ORsQ42nHYiSunXkDjPLBaEj/xTwUO4B7XCZQTRk7EBtTOPaygh10YAAh2OI1Qrp6NWfpAhzswj0ydt9g==}
 
   dom-serializer@1.4.1:
-    resolution:
-      {
-        integrity: sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==,
-      }
+    resolution: {integrity: sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==}
 
   dom-serializer@2.0.0:
-    resolution:
-      {
-        integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==,
-      }
+    resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==}
 
   domelementtype@1.3.1:
-    resolution:
-      {
-        integrity: sha512-BSKB+TSpMpFI/HOxCNr1O8aMOTZ8hT3pM3GQ0w/mWRmkhEDSFJkkyzz4XQsBV44BChwGkrDfMyjVD0eA2aFV3w==,
-      }
+    resolution: {integrity: sha512-BSKB+TSpMpFI/HOxCNr1O8aMOTZ8hT3pM3GQ0w/mWRmkhEDSFJkkyzz4XQsBV44BChwGkrDfMyjVD0eA2aFV3w==}
 
   domelementtype@2.3.0:
-    resolution:
-      {
-        integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==,
-      }
+    resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==}
 
   domhandler@2.4.2:
-    resolution:
-      {
-        integrity: sha512-JiK04h0Ht5u/80fdLMCEmV4zkNh2BcoMFBmZ/91WtYZ8qVXSKjiw7fXMgFPnHcSZgOo3XdinHvmnDUeMf5R4wA==,
-      }
+    resolution: {integrity: sha512-JiK04h0Ht5u/80fdLMCEmV4zkNh2BcoMFBmZ/91WtYZ8qVXSKjiw7fXMgFPnHcSZgOo3XdinHvmnDUeMf5R4wA==}
 
   domhandler@3.3.0:
-    resolution:
-      {
-        integrity: sha512-J1C5rIANUbuYK+FuFL98650rihynUOEzRLxW+90bKZRWB6A1X1Tf82GxR1qAWLyfNPRvjqfip3Q5tdYlmAa9lA==,
-      }
-    engines: { node: '>= 4' }
+    resolution: {integrity: sha512-J1C5rIANUbuYK+FuFL98650rihynUOEzRLxW+90bKZRWB6A1X1Tf82GxR1qAWLyfNPRvjqfip3Q5tdYlmAa9lA==}
+    engines: {node: '>= 4'}
 
   domhandler@4.3.1:
-    resolution:
-      {
-        integrity: sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==,
-      }
-    engines: { node: '>= 4' }
+    resolution: {integrity: sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==}
+    engines: {node: '>= 4'}
 
   domhandler@5.0.3:
-    resolution:
-      {
-        integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==,
-      }
-    engines: { node: '>= 4' }
+    resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==}
+    engines: {node: '>= 4'}
 
   domutils@1.5.1:
-    resolution:
-      {
-        integrity: sha512-gSu5Oi/I+3wDENBsOWBiRK1eoGxcywYSqg3rR960/+EfY0CF4EX1VPkgHOZ3WiS/Jg2DtliF6BhWcHlfpYUcGw==,
-      }
+    resolution: {integrity: sha512-gSu5Oi/I+3wDENBsOWBiRK1eoGxcywYSqg3rR960/+EfY0CF4EX1VPkgHOZ3WiS/Jg2DtliF6BhWcHlfpYUcGw==}
 
   domutils@1.7.0:
-    resolution:
-      {
-        integrity: sha512-Lgd2XcJ/NjEw+7tFvfKxOzCYKZsdct5lczQ2ZaQY8Djz7pfAD3Gbp8ySJWtreII/vDlMVmxwa6pHmdxIYgttDg==,
-      }
+    resolution: {integrity: sha512-Lgd2XcJ/NjEw+7tFvfKxOzCYKZsdct5lczQ2ZaQY8Djz7pfAD3Gbp8ySJWtreII/vDlMVmxwa6pHmdxIYgttDg==}
 
   domutils@2.8.0:
-    resolution:
-      {
-        integrity: sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==,
-      }
+    resolution: {integrity: sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==}
 
   domutils@3.2.2:
-    resolution:
-      {
-        integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==,
-      }
+    resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==}
 
   dot-prop@5.3.0:
-    resolution:
-      {
-        integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==}
+    engines: {node: '>=8'}
 
   dotenv-expand@11.0.7:
-    resolution:
-      {
-        integrity: sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==}
+    engines: {node: '>=12'}
 
   dotenv@16.4.7:
-    resolution:
-      {
-        integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==}
+    engines: {node: '>=12'}
 
   drizzle-orm@0.45.2:
-    resolution:
-      {
-        integrity: sha512-kY0BSaTNYWnoDMVoyY8uxmyHjpJW1geOmBMdSSicKo9CIIWkSxMIj2rkeSR51b8KAPB7m+qysjuHme5nKP+E5Q==,
-      }
+    resolution: {integrity: sha512-kY0BSaTNYWnoDMVoyY8uxmyHjpJW1geOmBMdSSicKo9CIIWkSxMIj2rkeSR51b8KAPB7m+qysjuHme5nKP+E5Q==}
     peerDependencies:
       '@aws-sdk/client-rds-data': '>=3'
       '@cloudflare/workers-types': '>=4'
@@ -9382,270 +7171,153 @@ packages:
         optional: true
 
   dunder-proto@1.0.1:
-    resolution:
-      {
-        integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
 
   eastasianwidth@0.2.0:
-    resolution:
-      {
-        integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==,
-      }
+    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
 
   ecdsa-sig-formatter@1.0.11:
-    resolution:
-      {
-        integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==,
-      }
+    resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
 
   editorconfig@1.0.4:
-    resolution:
-      {
-        integrity: sha512-L9Qe08KWTlqYMVvMcTIvMAdl1cDUubzRNYL+WfA4bLDMHe4nemKkpmYzkznE1FwLKu0EEmy6obgQKzMJrg4x9Q==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-L9Qe08KWTlqYMVvMcTIvMAdl1cDUubzRNYL+WfA4bLDMHe4nemKkpmYzkznE1FwLKu0EEmy6obgQKzMJrg4x9Q==}
+    engines: {node: '>=14'}
     hasBin: true
 
   ee-first@1.1.1:
-    resolution:
-      {
-        integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==,
-      }
+    resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
 
   ejs@3.1.10:
-    resolution:
-      {
-        integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==}
+    engines: {node: '>=0.10.0'}
     hasBin: true
 
   electron-to-chromium@1.5.267:
-    resolution:
-      {
-        integrity: sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==,
-      }
+    resolution: {integrity: sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==}
 
   emittery@0.13.1:
-    resolution:
-      {
-        integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==}
+    engines: {node: '>=12'}
 
   emoji-regex@8.0.0:
-    resolution:
-      {
-        integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==,
-      }
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
 
   emoji-regex@9.2.2:
-    resolution:
-      {
-        integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==,
-      }
+    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
 
   encodeurl@2.0.0:
-    resolution:
-      {
-        integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
+    engines: {node: '>= 0.8'}
 
   encoding-sniffer@0.2.1:
-    resolution:
-      {
-        integrity: sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw==,
-      }
+    resolution: {integrity: sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw==}
 
   encoding@0.1.13:
-    resolution:
-      {
-        integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==,
-      }
+    resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==}
 
   end-of-stream@1.4.5:
-    resolution:
-      {
-        integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==,
-      }
+    resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
 
   enquirer@2.3.6:
-    resolution:
-      {
-        integrity: sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==,
-      }
-    engines: { node: '>=8.6' }
+    resolution: {integrity: sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==}
+    engines: {node: '>=8.6'}
 
   entities@1.1.2:
-    resolution:
-      {
-        integrity: sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==,
-      }
+    resolution: {integrity: sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==}
 
   entities@2.2.0:
-    resolution:
-      {
-        integrity: sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==,
-      }
+    resolution: {integrity: sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==}
 
   entities@4.5.0:
-    resolution:
-      {
-        integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==,
-      }
-    engines: { node: '>=0.12' }
+    resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
+    engines: {node: '>=0.12'}
 
   entities@6.0.1:
-    resolution:
-      {
-        integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==,
-      }
-    engines: { node: '>=0.12' }
+    resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
+    engines: {node: '>=0.12'}
 
   env-paths@2.2.1:
-    resolution:
-      {
-        integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
+    engines: {node: '>=6'}
 
   envalid@8.1.1:
-    resolution:
-      {
-        integrity: sha512-vOUfHxAFFvkBjbVQbBfgnCO9d3GcNfMMTtVfgqSU2rQGMFEVqWy9GBuoSfHnwGu7EqR0/GeukQcL3KjFBaga9w==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-vOUfHxAFFvkBjbVQbBfgnCO9d3GcNfMMTtVfgqSU2rQGMFEVqWy9GBuoSfHnwGu7EqR0/GeukQcL3KjFBaga9w==}
+    engines: {node: '>=18'}
 
   envinfo@7.13.0:
-    resolution:
-      {
-        integrity: sha512-cvcaMr7KqXVh4nyzGTVqTum+gAiL265x5jUWQIDLq//zOGbW+gSW/C+OWLleY/rs9Qole6AZLMXPbtIFQbqu+Q==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-cvcaMr7KqXVh4nyzGTVqTum+gAiL265x5jUWQIDLq//zOGbW+gSW/C+OWLleY/rs9Qole6AZLMXPbtIFQbqu+Q==}
+    engines: {node: '>=4'}
     hasBin: true
 
   err-code@2.0.3:
-    resolution:
-      {
-        integrity: sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==,
-      }
+    resolution: {integrity: sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==}
 
   error-ex@1.3.4:
-    resolution:
-      {
-        integrity: sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==,
-      }
+    resolution: {integrity: sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==}
 
   es-define-property@1.0.1:
-    resolution:
-      {
-        integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
 
   es-errors@1.3.0:
-    resolution:
-      {
-        integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
 
   es-object-atoms@1.1.1:
-    resolution:
-      {
-        integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
 
   es-set-tostringtag@2.1.0:
-    resolution:
-      {
-        integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
+    engines: {node: '>= 0.4'}
 
   esbuild@0.25.12:
-    resolution:
-      {
-        integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==}
+    engines: {node: '>=18'}
     hasBin: true
 
   esbuild@0.27.2:
-    resolution:
-      {
-        integrity: sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==}
+    engines: {node: '>=18'}
     hasBin: true
 
   escalade@3.2.0:
-    resolution:
-      {
-        integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
 
   escape-goat@3.0.0:
-    resolution:
-      {
-        integrity: sha512-w3PwNZJwRxlp47QGzhuEBldEqVHHhh8/tIPcl6ecf2Bou99cdAt0knihBV0Ecc7CGxYduXVBDheH1K2oADRlvw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-w3PwNZJwRxlp47QGzhuEBldEqVHHhh8/tIPcl6ecf2Bou99cdAt0knihBV0Ecc7CGxYduXVBDheH1K2oADRlvw==}
+    engines: {node: '>=10'}
 
   escape-html@1.0.3:
-    resolution:
-      {
-        integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==,
-      }
+    resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
 
   escape-string-regexp@1.0.5:
-    resolution:
-      {
-        integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==,
-      }
-    engines: { node: '>=0.8.0' }
+    resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==}
+    engines: {node: '>=0.8.0'}
 
   escape-string-regexp@2.0.0:
-    resolution:
-      {
-        integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==}
+    engines: {node: '>=8'}
 
   escape-string-regexp@4.0.0:
-    resolution:
-      {
-        integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
 
   eslint-config-prettier@10.1.8:
-    resolution:
-      {
-        integrity: sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==,
-      }
+    resolution: {integrity: sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==}
     hasBin: true
     peerDependencies:
       eslint: '>=7.0.0'
 
   eslint-plugin-simple-import-sort@12.1.1:
-    resolution:
-      {
-        integrity: sha512-6nuzu4xwQtE3332Uz0to+TxDQYRLTKRESSc2hefVT48Zc8JthmN23Gx9lnYhu0FtkRSL1oxny3kJ2aveVhmOVA==,
-      }
+    resolution: {integrity: sha512-6nuzu4xwQtE3332Uz0to+TxDQYRLTKRESSc2hefVT48Zc8JthmN23Gx9lnYhu0FtkRSL1oxny3kJ2aveVhmOVA==}
     peerDependencies:
       eslint: '>=5.0.0'
 
   eslint-plugin-unused-imports@4.4.1:
-    resolution:
-      {
-        integrity: sha512-oZGYUz1X3sRMGUB+0cZyK2VcvRX5lm/vB56PgNNcU+7ficUCKm66oZWKUubXWnOuPjQ8PvmXtCViXBMONPe7tQ==,
-      }
+    resolution: {integrity: sha512-oZGYUz1X3sRMGUB+0cZyK2VcvRX5lm/vB56PgNNcU+7ficUCKm66oZWKUubXWnOuPjQ8PvmXtCViXBMONPe7tQ==}
     peerDependencies:
       '@typescript-eslint/eslint-plugin': ^8.0.0-0 || ^7.0.0 || ^6.0.0 || ^5.0.0
       eslint: ^10.0.0 || ^9.0.0 || ^8.0.0
@@ -9654,39 +7326,24 @@ packages:
         optional: true
 
   eslint-scope@8.4.0:
-    resolution:
-      {
-        integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   eslint-visitor-keys@3.4.3:
-    resolution:
-      {
-        integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==,
-      }
-    engines: { node: ^12.22.0 || ^14.17.0 || >=16.0.0 }
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
 
   eslint-visitor-keys@4.2.1:
-    resolution:
-      {
-        integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   eslint-visitor-keys@5.0.1:
-    resolution:
-      {
-        integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==,
-      }
-    engines: { node: ^20.19.0 || ^22.13.0 || >=24 }
+    resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
   eslint@9.39.2:
-    resolution:
-      {
-        integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     hasBin: true
     peerDependencies:
       jiti: '*'
@@ -9695,190 +7352,106 @@ packages:
         optional: true
 
   espree@10.4.0:
-    resolution:
-      {
-        integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==,
-      }
-    engines: { node: ^18.18.0 || ^20.9.0 || >=21.1.0 }
+    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   esprima@4.0.1:
-    resolution:
-      {
-        integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
     hasBin: true
 
   esquery@1.6.0:
-    resolution:
-      {
-        integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==,
-      }
-    engines: { node: '>=0.10' }
+    resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
+    engines: {node: '>=0.10'}
 
   esrecurse@4.3.0:
-    resolution:
-      {
-        integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==,
-      }
-    engines: { node: '>=4.0' }
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
 
   estraverse@5.3.0:
-    resolution:
-      {
-        integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==,
-      }
-    engines: { node: '>=4.0' }
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
 
   esutils@2.0.3:
-    resolution:
-      {
-        integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
 
   etag@1.8.1:
-    resolution:
-      {
-        integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
+    engines: {node: '>= 0.6'}
 
   eventemitter3@4.0.7:
-    resolution:
-      {
-        integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==,
-      }
+    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
 
   eventemitter3@5.0.4:
-    resolution:
-      {
-        integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==,
-      }
+    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
 
   events@3.3.0:
-    resolution:
-      {
-        integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==,
-      }
-    engines: { node: '>=0.8.x' }
+    resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
+    engines: {node: '>=0.8.x'}
 
   execa@5.0.0:
-    resolution:
-      {
-        integrity: sha512-ov6w/2LCiuyO4RLYGdpFGjkcs0wMTgGE8PrkTHikeUy5iJekXyPIKUjifk5CsE0pt7sMCrMZ3YNqoCj6idQOnQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-ov6w/2LCiuyO4RLYGdpFGjkcs0wMTgGE8PrkTHikeUy5iJekXyPIKUjifk5CsE0pt7sMCrMZ3YNqoCj6idQOnQ==}
+    engines: {node: '>=10'}
 
   execa@5.1.1:
-    resolution:
-      {
-        integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
 
   exit-x@0.2.2:
-    resolution:
-      {
-        integrity: sha512-+I6B/IkJc1o/2tiURyz/ivu/O0nKNEArIUB5O7zBrlDVJr22SCLH3xTeEry428LvFhRzIA1g8izguxJ/gbNcVQ==,
-      }
-    engines: { node: '>= 0.8.0' }
+    resolution: {integrity: sha512-+I6B/IkJc1o/2tiURyz/ivu/O0nKNEArIUB5O7zBrlDVJr22SCLH3xTeEry428LvFhRzIA1g8izguxJ/gbNcVQ==}
+    engines: {node: '>= 0.8.0'}
 
   expect@30.2.0:
-    resolution:
-      {
-        integrity: sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   expect@30.4.1:
-    resolution:
-      {
-        integrity: sha512-PMARsyh/JtqC20HoGqlFcIlQAyqUtW4PlI1rup1uhYJtKuwAjbvWi3GQMAn+STdHum/dk8xrKfUM1+5SAwpolA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-PMARsyh/JtqC20HoGqlFcIlQAyqUtW4PlI1rup1uhYJtKuwAjbvWi3GQMAn+STdHum/dk8xrKfUM1+5SAwpolA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   exponential-backoff@3.1.3:
-    resolution:
-      {
-        integrity: sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==,
-      }
+    resolution: {integrity: sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==}
 
   express@5.2.1:
-    resolution:
-      {
-        integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==}
+    engines: {node: '>= 18'}
 
   fast-deep-equal@3.1.3:
-    resolution:
-      {
-        integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==,
-      }
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
   fast-glob@3.3.3:
-    resolution:
-      {
-        integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==,
-      }
-    engines: { node: '>=8.6.0' }
+    resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
+    engines: {node: '>=8.6.0'}
 
   fast-json-stable-stringify@2.1.0:
-    resolution:
-      {
-        integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==,
-      }
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
 
   fast-levenshtein@2.0.6:
-    resolution:
-      {
-        integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==,
-      }
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
 
   fast-safe-stringify@2.1.1:
-    resolution:
-      {
-        integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==,
-      }
+    resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==}
 
   fast-uri@3.1.2:
-    resolution:
-      {
-        integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==,
-      }
+    resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==}
 
   fast-xml-builder@1.2.0:
-    resolution:
-      {
-        integrity: sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==,
-      }
+    resolution: {integrity: sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==}
 
   fast-xml-parser@5.7.3:
-    resolution:
-      {
-        integrity: sha512-C0AaNuC+mscy6vrAQKAc/rMq+zAPHodfHGZu4sGVehvAQt/JLG1O5zEcYcXSY5zSqr4YVgxsB+pHXTq0i7eDlg==,
-      }
+    resolution: {integrity: sha512-C0AaNuC+mscy6vrAQKAc/rMq+zAPHodfHGZu4sGVehvAQt/JLG1O5zEcYcXSY5zSqr4YVgxsB+pHXTq0i7eDlg==}
     hasBin: true
 
   fastq@1.20.1:
-    resolution:
-      {
-        integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==,
-      }
+    resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
 
   fb-watchman@2.0.2:
-    resolution:
-      {
-        integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==,
-      }
+    resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==}
 
   fdir@6.5.0:
-    resolution:
-      {
-        integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==,
-      }
-    engines: { node: '>=12.0.0' }
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
     peerDependencies:
       picomatch: ^3 || ^4
     peerDependenciesMeta:
@@ -9886,92 +7459,53 @@ packages:
         optional: true
 
   figures@3.2.0:
-    resolution:
-      {
-        integrity: sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==}
+    engines: {node: '>=8'}
 
   file-entry-cache@8.0.0:
-    resolution:
-      {
-        integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==,
-      }
-    engines: { node: '>=16.0.0' }
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
 
   filelist@1.0.4:
-    resolution:
-      {
-        integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==,
-      }
+    resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==}
 
   fill-range@7.1.1:
-    resolution:
-      {
-        integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
 
   finalhandler@2.1.1:
-    resolution:
-      {
-        integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==,
-      }
-    engines: { node: '>= 18.0.0' }
+    resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==}
+    engines: {node: '>= 18.0.0'}
 
   find-and-require-package-json@0.9.1:
-    resolution:
-      {
-        integrity: sha512-jFpCL0XgjipSk109viUtfp+NyR/oW6a4Xus4tV3UYkmCbsjisEeZD1x5QnD1NDDK/hXas1WFs4yO13L4TPXWlQ==,
-      }
+    resolution: {integrity: sha512-jFpCL0XgjipSk109viUtfp+NyR/oW6a4Xus4tV3UYkmCbsjisEeZD1x5QnD1NDDK/hXas1WFs4yO13L4TPXWlQ==}
 
   find-up@2.1.0:
-    resolution:
-      {
-        integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==}
+    engines: {node: '>=4'}
 
   find-up@4.1.0:
-    resolution:
-      {
-        integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
+    engines: {node: '>=8'}
 
   find-up@5.0.0:
-    resolution:
-      {
-        integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
 
   flat-cache@4.0.1:
-    resolution:
-      {
-        integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==,
-      }
-    engines: { node: '>=16' }
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
 
   flat@5.0.2:
-    resolution:
-      {
-        integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==,
-      }
+    resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==}
     hasBin: true
 
   flatted@3.3.3:
-    resolution:
-      {
-        integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==,
-      }
+    resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
 
   follow-redirects@1.15.11:
-    resolution:
-      {
-        integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==,
-      }
-    engines: { node: '>=4.0' }
+    resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==}
+    engines: {node: '>=4.0'}
     peerDependencies:
       debug: '*'
     peerDependenciesMeta:
@@ -9979,38 +7513,23 @@ packages:
         optional: true
 
   foreground-child@3.3.1:
-    resolution:
-      {
-        integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
+    engines: {node: '>=14'}
 
   form-data@4.0.5:
-    resolution:
-      {
-        integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==}
+    engines: {node: '>= 6'}
 
   formidable@3.5.4:
-    resolution:
-      {
-        integrity: sha512-YikH+7CUTOtP44ZTnUhR7Ic2UASBPOqmaRkRKxRbywPTe5VxF7RRCck4af9wutiZ/QKM5nME9Bie2fFaPz5Gug==,
-      }
-    engines: { node: '>=14.0.0' }
+    resolution: {integrity: sha512-YikH+7CUTOtP44ZTnUhR7Ic2UASBPOqmaRkRKxRbywPTe5VxF7RRCck4af9wutiZ/QKM5nME9Bie2fFaPz5Gug==}
+    engines: {node: '>=14.0.0'}
 
   forwarded@0.2.0:
-    resolution:
-      {
-        integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
+    engines: {node: '>= 0.6'}
 
   framer-motion@12.36.0:
-    resolution:
-      {
-        integrity: sha512-4PqYHAT7gev0ke0wos+PyrcFxI0HScjm3asgU8nSYa8YzJFuwgIvdj3/s3ZaxLq0bUSboIn19A2WS/MHwLCvfw==,
-      }
+    resolution: {integrity: sha512-4PqYHAT7gev0ke0wos+PyrcFxI0HScjm3asgU8nSYa8YzJFuwgIvdj3/s3ZaxLq0bUSboIn19A2WS/MHwLCvfw==}
     peerDependencies:
       '@emotion/is-prop-valid': '*'
       react: ^18.0.0 || ^19.0.0
@@ -10024,299 +7543,173 @@ packages:
         optional: true
 
   fresh@2.0.0:
-    resolution:
-      {
-        integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
+    engines: {node: '>= 0.8'}
 
   front-matter@4.0.2:
-    resolution:
-      {
-        integrity: sha512-I8ZuJ/qG92NWX8i5x1Y8qyj3vizhXS31OxjKDu3LKP+7/qBgfIKValiZIEwoVoJKUHlhWtYrktkxV1XsX+pPlg==,
-      }
+    resolution: {integrity: sha512-I8ZuJ/qG92NWX8i5x1Y8qyj3vizhXS31OxjKDu3LKP+7/qBgfIKValiZIEwoVoJKUHlhWtYrktkxV1XsX+pPlg==}
 
   fs-capacitor@6.2.0:
-    resolution:
-      {
-        integrity: sha512-nKcE1UduoSKX27NSZlg879LdQc94OtbOsEmKMN2MBNudXREvijRKx2GEBsTMTfws+BrbkJoEuynbGSVRSpauvw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-nKcE1UduoSKX27NSZlg879LdQc94OtbOsEmKMN2MBNudXREvijRKx2GEBsTMTfws+BrbkJoEuynbGSVRSpauvw==}
+    engines: {node: '>=10'}
 
   fs-capacitor@8.0.0:
-    resolution:
-      {
-        integrity: sha512-+Lk6iSKajdGw+7XYxUkwIzreJ2G1JFlYOdnKJv5PzwFLVsoJYBpCuS7WPIUSNT1IbQaEWT1nhYU63Ud03DyzLA==,
-      }
-    engines: { node: ^14.17.0 || >=16.0.0 }
+    resolution: {integrity: sha512-+Lk6iSKajdGw+7XYxUkwIzreJ2G1JFlYOdnKJv5PzwFLVsoJYBpCuS7WPIUSNT1IbQaEWT1nhYU63Ud03DyzLA==}
+    engines: {node: ^14.17.0 || >=16.0.0}
 
   fs-constants@1.0.0:
-    resolution:
-      {
-        integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==,
-      }
+    resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
 
   fs-extra@11.3.3:
-    resolution:
-      {
-        integrity: sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg==,
-      }
-    engines: { node: '>=14.14' }
+    resolution: {integrity: sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg==}
+    engines: {node: '>=14.14'}
 
   fs-minipass@2.1.0:
-    resolution:
-      {
-        integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
+    engines: {node: '>= 8'}
 
   fs-minipass@3.0.3:
-    resolution:
-      {
-        integrity: sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   fs.realpath@1.0.0:
-    resolution:
-      {
-        integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==,
-      }
+    resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
 
   fsevents@2.3.2:
-    resolution:
-      {
-        integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==,
-      }
-    engines: { node: ^8.16.0 || ^10.6.0 || >=11.0.0 }
+    resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
 
   fsevents@2.3.3:
-    resolution:
-      {
-        integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==,
-      }
-    engines: { node: ^8.16.0 || ^10.6.0 || >=11.0.0 }
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
 
   function-bind@1.1.2:
-    resolution:
-      {
-        integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==,
-      }
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
 
   genomic@5.6.2:
-    resolution:
-      {
-        integrity: sha512-y2LK1KQjeZZ4WT0DEQhjTxMNs+hsoZTclIqdnU5Xo3Ie8phDB6ynw8Sk2NLtELL7H3Q26tvZBJkckIkaSa0Lag==,
-      }
+    resolution: {integrity: sha512-y2LK1KQjeZZ4WT0DEQhjTxMNs+hsoZTclIqdnU5Xo3Ie8phDB6ynw8Sk2NLtELL7H3Q26tvZBJkckIkaSa0Lag==}
 
   gensync@1.0.0-beta.2:
-    resolution:
-      {
-        integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
+    engines: {node: '>=6.9.0'}
 
   get-caller-file@2.0.5:
-    resolution:
-      {
-        integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==,
-      }
-    engines: { node: 6.* || 8.* || >= 10.* }
+    resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
+    engines: {node: 6.* || 8.* || >= 10.*}
 
   get-intrinsic@1.3.0:
-    resolution:
-      {
-        integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
 
   get-nonce@1.0.1:
-    resolution:
-      {
-        integrity: sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==}
+    engines: {node: '>=6'}
 
   get-package-type@0.1.0:
-    resolution:
-      {
-        integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==,
-      }
-    engines: { node: '>=8.0.0' }
+    resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==}
+    engines: {node: '>=8.0.0'}
 
   get-pkg-repo@4.2.1:
-    resolution:
-      {
-        integrity: sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==,
-      }
-    engines: { node: '>=6.9.0' }
+    resolution: {integrity: sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==}
+    engines: {node: '>=6.9.0'}
     hasBin: true
 
   get-port@5.1.1:
-    resolution:
-      {
-        integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==}
+    engines: {node: '>=8'}
 
   get-proto@1.0.1:
-    resolution:
-      {
-        integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
 
   get-stream@6.0.0:
-    resolution:
-      {
-        integrity: sha512-A1B3Bh1UmL0bidM/YX2NsCOTnGJePL9rO/M+Mw3m9f2gUpfokS0hi5Eah0WSUEWZdZhIZtMjkIYS7mDfOqNHbg==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-A1B3Bh1UmL0bidM/YX2NsCOTnGJePL9rO/M+Mw3m9f2gUpfokS0hi5Eah0WSUEWZdZhIZtMjkIYS7mDfOqNHbg==}
+    engines: {node: '>=10'}
 
   get-stream@6.0.1:
-    resolution:
-      {
-        integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
 
   get-tsconfig@4.13.0:
-    resolution:
-      {
-        integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==,
-      }
+    resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==}
 
   get-value@3.0.1:
-    resolution:
-      {
-        integrity: sha512-mKZj9JLQrwMBtj5wxi6MH8Z5eSKaERpAwjg43dPtlGI1ZVEgH/qC7T8/6R2OBSUA+zzHBZgICsVJaEIV2tKTDA==,
-      }
-    engines: { node: '>=6.0' }
+    resolution: {integrity: sha512-mKZj9JLQrwMBtj5wxi6MH8Z5eSKaERpAwjg43dPtlGI1ZVEgH/qC7T8/6R2OBSUA+zzHBZgICsVJaEIV2tKTDA==}
+    engines: {node: '>=6.0'}
 
   git-raw-commits@3.0.0:
-    resolution:
-      {
-        integrity: sha512-b5OHmZ3vAgGrDn/X0kS+9qCfNKWe4K/jFnhwzVWWg0/k5eLa3060tZShrRg8Dja5kPc+YjS0Gc6y7cRr44Lpjw==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-b5OHmZ3vAgGrDn/X0kS+9qCfNKWe4K/jFnhwzVWWg0/k5eLa3060tZShrRg8Dja5kPc+YjS0Gc6y7cRr44Lpjw==}
+    engines: {node: '>=14'}
     deprecated: This package is no longer maintained. For the JavaScript API, please use @conventional-changelog/git-client instead.
     hasBin: true
 
   git-remote-origin-url@2.0.0:
-    resolution:
-      {
-        integrity: sha512-eU+GGrZgccNJcsDH5LkXR3PB9M958hxc7sbA8DFJjrv9j4L2P/eZfKhM+QD6wyzpiv+b1BpK0XrYCxkovtjSLw==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-eU+GGrZgccNJcsDH5LkXR3PB9M958hxc7sbA8DFJjrv9j4L2P/eZfKhM+QD6wyzpiv+b1BpK0XrYCxkovtjSLw==}
+    engines: {node: '>=4'}
 
   git-semver-tags@5.0.1:
-    resolution:
-      {
-        integrity: sha512-hIvOeZwRbQ+7YEUmCkHqo8FOLQZCEn18yevLHADlFPZY02KJGsu5FZt9YW/lybfK2uhWFI7Qg/07LekJiTv7iA==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-hIvOeZwRbQ+7YEUmCkHqo8FOLQZCEn18yevLHADlFPZY02KJGsu5FZt9YW/lybfK2uhWFI7Qg/07LekJiTv7iA==}
+    engines: {node: '>=14'}
     deprecated: This package is no longer maintained. For the JavaScript API, please use @conventional-changelog/git-client instead.
     hasBin: true
 
   git-up@7.0.0:
-    resolution:
-      {
-        integrity: sha512-ONdIrbBCFusq1Oy0sC71F5azx8bVkvtZtMJAsv+a6lz5YAmbNnLD6HAB4gptHZVLPR8S2/kVN6Gab7lryq5+lQ==,
-      }
+    resolution: {integrity: sha512-ONdIrbBCFusq1Oy0sC71F5azx8bVkvtZtMJAsv+a6lz5YAmbNnLD6HAB4gptHZVLPR8S2/kVN6Gab7lryq5+lQ==}
 
   git-url-parse@14.0.0:
-    resolution:
-      {
-        integrity: sha512-NnLweV+2A4nCvn4U/m2AoYu0pPKlsmhK9cknG7IMwsjFY1S2jxM+mAhsDxyxfCIGfGaD+dozsyX4b6vkYc83yQ==,
-      }
+    resolution: {integrity: sha512-NnLweV+2A4nCvn4U/m2AoYu0pPKlsmhK9cknG7IMwsjFY1S2jxM+mAhsDxyxfCIGfGaD+dozsyX4b6vkYc83yQ==}
 
   gitconfiglocal@1.0.0:
-    resolution:
-      {
-        integrity: sha512-spLUXeTAVHxDtKsJc8FkFVgFtMdEN9qPGpL23VfSHx4fP4+Ds097IXLvymbnDH8FnmxX5Nr9bPw3A+AQ6mWEaQ==,
-      }
+    resolution: {integrity: sha512-spLUXeTAVHxDtKsJc8FkFVgFtMdEN9qPGpL23VfSHx4fP4+Ds097IXLvymbnDH8FnmxX5Nr9bPw3A+AQ6mWEaQ==}
 
   glob-parent@5.1.2:
-    resolution:
-      {
-        integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
 
   glob-parent@6.0.2:
-    resolution:
-      {
-        integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==,
-      }
-    engines: { node: '>=10.13.0' }
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
 
   glob@10.5.0:
-    resolution:
-      {
-        integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==,
-      }
+    resolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==}
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
   glob@11.1.0:
-    resolution:
-      {
-        integrity: sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==,
-      }
-    engines: { node: 20 || >=22 }
+    resolution: {integrity: sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==}
+    engines: {node: 20 || >=22}
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
     hasBin: true
 
   glob@13.0.6:
-    resolution:
-      {
-        integrity: sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==,
-      }
-    engines: { node: 18 || 20 || >=22 }
+    resolution: {integrity: sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==}
+    engines: {node: 18 || 20 || >=22}
 
   glob@7.2.3:
-    resolution:
-      {
-        integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==,
-      }
+    resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   glob@9.3.5:
-    resolution:
-      {
-        integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==}
+    engines: {node: '>=16 || 14 >=14.17'}
     deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   globals@14.0.0:
-    resolution:
-      {
-        integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
+    engines: {node: '>=18'}
 
   gopd@1.2.0:
-    resolution:
-      {
-        integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
 
   graceful-fs@4.2.11:
-    resolution:
-      {
-        integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==,
-      }
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
 
   grafast@1.0.2:
-    resolution:
-      {
-        integrity: sha512-E3PH6hfOfhlJxMmiBplWs3KDmJTIQr/iZ9hs4c73k3pLk9Tx2nSdVNBVIe7D1stejgPbyC6wRxLfXtJmDx2P7A==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-E3PH6hfOfhlJxMmiBplWs3KDmJTIQr/iZ9hs4c73k3pLk9Tx2nSdVNBVIe7D1stejgPbyC6wRxLfXtJmDx2P7A==}
+    engines: {node: '>=22'}
     peerDependencies:
       '@envelop/core': ^5.0.0
       graphql: 16.13.0
@@ -10325,11 +7718,8 @@ packages:
         optional: true
 
   grafserv@1.0.0:
-    resolution:
-      {
-        integrity: sha512-9w0zwYSHS10DfHOAQhaCVvJnOFuk+YY+nZZqG0ZOqFbner3Zf4GvqfWlNETdmUQdB6dnISfGZCkIaSZt5R7wCQ==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-9w0zwYSHS10DfHOAQhaCVvJnOFuk+YY+nZZqG0ZOqFbner3Zf4GvqfWlNETdmUQdB6dnISfGZCkIaSZt5R7wCQ==}
+    engines: {node: '>=22'}
     peerDependencies:
       '@envelop/core': ^5.0.0
       '@whatwg-node/server': ^0.9.64
@@ -10352,11 +7742,8 @@ packages:
         optional: true
 
   graphile-build-pg@5.0.2:
-    resolution:
-      {
-        integrity: sha512-8vkg1x5UcooFogPCp+3EUt6qqWX8NG01gANoVFUk9yK2c8DW+aQaF37LAaa96r9JR4FE0yeO2zk6WvOOemk2dg==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-8vkg1x5UcooFogPCp+3EUt6qqWX8NG01gANoVFUk9yK2c8DW+aQaF37LAaa96r9JR4FE0yeO2zk6WvOOemk2dg==}
+    engines: {node: '>=22'}
     peerDependencies:
       '@dataplan/pg': ^1.0.0-rc.7
       grafast: ^1.0.0-rc.8
@@ -10371,28 +7758,19 @@ packages:
         optional: true
 
   graphile-build@5.0.2:
-    resolution:
-      {
-        integrity: sha512-ELhDDZ2Y3ZWmF+ZziEd9ytMxFnmBoCX4/1My2Jhifr1FUD9IzWFhzH2qAWKmTvDrIy7b6jc4SV23lWmTbiD3ZA==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-ELhDDZ2Y3ZWmF+ZziEd9ytMxFnmBoCX4/1My2Jhifr1FUD9IzWFhzH2qAWKmTvDrIy7b6jc4SV23lWmTbiD3ZA==}
+    engines: {node: '>=22'}
     peerDependencies:
       grafast: ^1.0.0-rc.8
       graphile-config: ^1.0.0-rc.5
       graphql: 16.13.0
 
   graphile-config@1.0.1:
-    resolution:
-      {
-        integrity: sha512-sVdSWNmetW/WZKVQ0Dii2kCu0Le6X6qwuBRecWg575iOMjbZgxo+b4oVeSOTtR6NTKuLsMYQBkzSaeoAKOPB+A==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-sVdSWNmetW/WZKVQ0Dii2kCu0Le6X6qwuBRecWg575iOMjbZgxo+b4oVeSOTtR6NTKuLsMYQBkzSaeoAKOPB+A==}
+    engines: {node: '>=22'}
 
   graphile-connection-filter@1.14.0:
-    resolution:
-      {
-        integrity: sha512-4u1cRjHKQCSAzYfsQW6dBGQq/0X6HUdSFMaPnNX92ckUCfQoO9RiMyTrP9zxeVvMt5Y8rLvFfuTZIv2Gj6gC8A==,
-      }
+    resolution: {integrity: sha512-4u1cRjHKQCSAzYfsQW6dBGQq/0X6HUdSFMaPnNX92ckUCfQoO9RiMyTrP9zxeVvMt5Y8rLvFfuTZIv2Gj6gC8A==}
     peerDependencies:
       '@dataplan/pg': 1.0.3
       graphile-build: 5.0.2
@@ -10403,11 +7781,8 @@ packages:
       postgraphile: 5.0.3
 
   graphile-utils@5.0.0:
-    resolution:
-      {
-        integrity: sha512-W/qzi7o6w4cakNqapeGNSGmYq0QowsiT0okPdmdUmZe117XiGPACzL+H0vqG0ZqkLUjZ5vNTIOGYQVqJ4Tg6KA==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-W/qzi7o6w4cakNqapeGNSGmYq0QowsiT0okPdmdUmZe117XiGPACzL+H0vqG0ZqkLUjZ5vNTIOGYQVqJ4Tg6KA==}
+    engines: {node: '>=22'}
     peerDependencies:
       '@dataplan/pg': ^1.0.0-rc.7
       grafast: ^1.0.0-rc.8
@@ -10421,11 +7796,8 @@ packages:
         optional: true
 
   graphile-utils@5.0.1:
-    resolution:
-      {
-        integrity: sha512-FtJgxL2BDv1B417sOCsNdu1e3yZkZY7jPMlMHTvzcJLc/7o9rDh+ucJGDmLiKe5Z4lS8KXxVRLZWbxC56/RHcw==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-FtJgxL2BDv1B417sOCsNdu1e3yZkZY7jPMlMHTvzcJLc/7o9rDh+ucJGDmLiKe5Z4lS8KXxVRLZWbxC56/RHcw==}
+    engines: {node: '>=22'}
     peerDependencies:
       '@dataplan/pg': ^1.0.0-rc.7
       grafast: ^1.0.0-rc.8
@@ -10439,56 +7811,38 @@ packages:
         optional: true
 
   graphiql@5.2.2:
-    resolution:
-      {
-        integrity: sha512-qYhw7e2QPLPEIdJXqlLa/XkZtEu2SVYyD71abOpPnrzmJzTdB+QsEswFIMg9u1WGkEtp/wi8epCsuKeA/chRcg==,
-      }
+    resolution: {integrity: sha512-qYhw7e2QPLPEIdJXqlLa/XkZtEu2SVYyD71abOpPnrzmJzTdB+QsEswFIMg9u1WGkEtp/wi8epCsuKeA/chRcg==}
     peerDependencies:
       graphql: 16.13.0
       react: ^18 || ^19
       react-dom: ^18 || ^19
 
   graphql-language-service@5.5.0:
-    resolution:
-      {
-        integrity: sha512-9EvWrLLkF6Y5e29/2cmFoAO6hBPPAZlCyjznmpR11iFtRydfkss+9m6x+htA8h7YznGam+TtJwS6JuwoWWgb2Q==,
-      }
+    resolution: {integrity: sha512-9EvWrLLkF6Y5e29/2cmFoAO6hBPPAZlCyjznmpR11iFtRydfkss+9m6x+htA8h7YznGam+TtJwS6JuwoWWgb2Q==}
     hasBin: true
     peerDependencies:
       graphql: 16.13.0
 
   graphql-request@7.4.0:
-    resolution:
-      {
-        integrity: sha512-xfr+zFb/QYbs4l4ty0dltqiXIp07U6sl+tOKAb0t50/EnQek6CVVBLjETXi+FghElytvgaAWtIOt3EV7zLzIAQ==,
-      }
+    resolution: {integrity: sha512-xfr+zFb/QYbs4l4ty0dltqiXIp07U6sl+tOKAb0t50/EnQek6CVVBLjETXi+FghElytvgaAWtIOt3EV7zLzIAQ==}
     peerDependencies:
       graphql: 16.13.0
 
   graphql-tag@2.12.6:
-    resolution:
-      {
-        integrity: sha512-FdSNcu2QQcWnM2VNvSCCDCVS5PpPqpzgFT8+GXzqJuoDd0CBncxCY278u4mhRO7tMgo2JjgJA5aZ+nWSQ/Z+xg==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-FdSNcu2QQcWnM2VNvSCCDCVS5PpPqpzgFT8+GXzqJuoDd0CBncxCY278u4mhRO7tMgo2JjgJA5aZ+nWSQ/Z+xg==}
+    engines: {node: '>=10'}
     peerDependencies:
       graphql: 16.13.0
 
   graphql-upload@13.0.0:
-    resolution:
-      {
-        integrity: sha512-YKhx8m/uOtKu4Y1UzBFJhbBGJTlk7k4CydlUUiNrtxnwZv0WigbRHP+DVhRNKt7u7DXOtcKZeYJlGtnMXvreXA==,
-      }
-    engines: { node: ^12.22.0 || ^14.17.0 || >= 16.0.0 }
+    resolution: {integrity: sha512-YKhx8m/uOtKu4Y1UzBFJhbBGJTlk7k4CydlUUiNrtxnwZv0WigbRHP+DVhRNKt7u7DXOtcKZeYJlGtnMXvreXA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >= 16.0.0}
     peerDependencies:
       graphql: 16.13.0
 
   graphql-ws@6.0.8:
-    resolution:
-      {
-        integrity: sha512-m3EOaNsUBXwAnkBWbzPfe0Nq8pXUfxsWnolC54sru3FzHvhTZL0Ouf/BoQsaGAXqM+YPerXOJ47BUnmgmoupCw==,
-      }
-    engines: { node: '>=20' }
+    resolution: {integrity: sha512-m3EOaNsUBXwAnkBWbzPfe0Nq8pXUfxsWnolC54sru3FzHvhTZL0Ouf/BoQsaGAXqM+YPerXOJ47BUnmgmoupCw==}
+    engines: {node: '>=20'}
     peerDependencies:
       '@fastify/websocket': ^10 || ^11
       crossws: ~0.3
@@ -10503,636 +7857,357 @@ packages:
         optional: true
 
   graphql@16.13.0:
-    resolution:
-      {
-        integrity: sha512-uSisMYERbaB9bkA9M4/4dnqyktaEkf1kMHNKq/7DHyxVeWqHQ2mBmVqm5u6/FVHwF3iCNalKcg82Zfl+tffWoA==,
-      }
-    engines: { node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0 }
+    resolution: {integrity: sha512-uSisMYERbaB9bkA9M4/4dnqyktaEkf1kMHNKq/7DHyxVeWqHQ2mBmVqm5u6/FVHwF3iCNalKcg82Zfl+tffWoA==}
+    engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0}
 
   handlebars@4.7.9:
-    resolution:
-      {
-        integrity: sha512-4E71E0rpOaQuJR2A3xDZ+GM1HyWYv1clR58tC8emQNeQe3RH7MAzSbat+V0wG78LQBo6m6bzSG/L4pBuCsgnUQ==,
-      }
-    engines: { node: '>=0.4.7' }
+    resolution: {integrity: sha512-4E71E0rpOaQuJR2A3xDZ+GM1HyWYv1clR58tC8emQNeQe3RH7MAzSbat+V0wG78LQBo6m6bzSG/L4pBuCsgnUQ==}
+    engines: {node: '>=0.4.7'}
     hasBin: true
 
   hard-rejection@2.1.0:
-    resolution:
-      {
-        integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==}
+    engines: {node: '>=6'}
 
   has-flag@3.0.0:
-    resolution:
-      {
-        integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
+    engines: {node: '>=4'}
 
   has-flag@4.0.0:
-    resolution:
-      {
-        integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
 
   has-symbols@1.1.0:
-    resolution:
-      {
-        integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
 
   has-tostringtag@1.0.2:
-    resolution:
-      {
-        integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
+    engines: {node: '>= 0.4'}
 
   has-unicode@2.0.1:
-    resolution:
-      {
-        integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==,
-      }
+    resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==}
 
   hasown@2.0.2:
-    resolution:
-      {
-        integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
 
   he@1.2.0:
-    resolution:
-      {
-        integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==,
-      }
+    resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
     hasBin: true
 
   hoist-non-react-statics@3.3.2:
-    resolution:
-      {
-        integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==,
-      }
+    resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==}
 
   hosted-git-info@2.8.9:
-    resolution:
-      {
-        integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==,
-      }
+    resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==}
 
   hosted-git-info@4.1.0:
-    resolution:
-      {
-        integrity: sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==}
+    engines: {node: '>=10'}
 
   hosted-git-info@7.0.2:
-    resolution:
-      {
-        integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   html-encoding-sniffer@4.0.0:
-    resolution:
-      {
-        integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
+    engines: {node: '>=18'}
 
   html-escaper@2.0.2:
-    resolution:
-      {
-        integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==,
-      }
+    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
 
   html-minifier@3.5.21:
-    resolution:
-      {
-        integrity: sha512-LKUKwuJDhxNa3uf/LPR/KVjm/l3rBqtYeCOAekvG8F1vItxMUpueGd94i/asDDr8/1u7InxzFA5EeGjhhG5mMA==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-LKUKwuJDhxNa3uf/LPR/KVjm/l3rBqtYeCOAekvG8F1vItxMUpueGd94i/asDDr8/1u7InxzFA5EeGjhhG5mMA==}
+    engines: {node: '>=4'}
     hasBin: true
 
   htmlparser2@10.0.0:
-    resolution:
-      {
-        integrity: sha512-TwAZM+zE5Tq3lrEHvOlvwgj1XLWQCtaaibSN11Q+gGBAS7Y1uZSWwXXRe4iF6OXnaq1riyQAPFOBtYc77Mxq0g==,
-      }
+    resolution: {integrity: sha512-TwAZM+zE5Tq3lrEHvOlvwgj1XLWQCtaaibSN11Q+gGBAS7Y1uZSWwXXRe4iF6OXnaq1riyQAPFOBtYc77Mxq0g==}
 
   htmlparser2@3.10.1:
-    resolution:
-      {
-        integrity: sha512-IgieNijUMbkDovyoKObU1DUhm1iwNYE/fuifEoEHfd1oZKZDaONBSkal7Y01shxsM49R4XaMdGez3WnF9UfiCQ==,
-      }
+    resolution: {integrity: sha512-IgieNijUMbkDovyoKObU1DUhm1iwNYE/fuifEoEHfd1oZKZDaONBSkal7Y01shxsM49R4XaMdGez3WnF9UfiCQ==}
 
   htmlparser2@4.1.0:
-    resolution:
-      {
-        integrity: sha512-4zDq1a1zhE4gQso/c5LP1OtrhYTncXNSpvJYtWJBtXAETPlMfi3IFNjGuQbYLuVY4ZR0QMqRVvo4Pdy9KLyP8Q==,
-      }
+    resolution: {integrity: sha512-4zDq1a1zhE4gQso/c5LP1OtrhYTncXNSpvJYtWJBtXAETPlMfi3IFNjGuQbYLuVY4ZR0QMqRVvo4Pdy9KLyP8Q==}
 
   http-cache-semantics@4.2.0:
-    resolution:
-      {
-        integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==,
-      }
+    resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==}
 
   http-errors@1.8.1:
-    resolution:
-      {
-        integrity: sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==}
+    engines: {node: '>= 0.6'}
 
   http-errors@2.0.1:
-    resolution:
-      {
-        integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
+    engines: {node: '>= 0.8'}
 
   http-proxy-agent@7.0.2:
-    resolution:
-      {
-        integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==,
-      }
-    engines: { node: '>= 14' }
+    resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
+    engines: {node: '>= 14'}
 
   http-proxy@1.18.1:
-    resolution:
-      {
-        integrity: sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==,
-      }
-    engines: { node: '>=8.0.0' }
+    resolution: {integrity: sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==}
+    engines: {node: '>=8.0.0'}
 
   https-proxy-agent@7.0.6:
-    resolution:
-      {
-        integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==,
-      }
-    engines: { node: '>= 14' }
+    resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
+    engines: {node: '>= 14'}
 
   human-signals@2.1.0:
-    resolution:
-      {
-        integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==,
-      }
-    engines: { node: '>=10.17.0' }
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
 
   iconv-lite@0.6.3:
-    resolution:
-      {
-        integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
+    engines: {node: '>=0.10.0'}
 
   iconv-lite@0.7.1:
-    resolution:
-      {
-        integrity: sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw==}
+    engines: {node: '>=0.10.0'}
 
   ieee754@1.2.1:
-    resolution:
-      {
-        integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==,
-      }
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
 
   ignore-by-default@1.0.1:
-    resolution:
-      {
-        integrity: sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==,
-      }
+    resolution: {integrity: sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==}
 
   ignore-walk@6.0.5:
-    resolution:
-      {
-        integrity: sha512-VuuG0wCnjhnylG1ABXT3dAuIpTNDs/G8jlpmwXY03fXoXy/8ZK8/T+hMzt8L4WnrLCJgdybqgPagnF/f97cg3A==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-VuuG0wCnjhnylG1ABXT3dAuIpTNDs/G8jlpmwXY03fXoXy/8ZK8/T+hMzt8L4WnrLCJgdybqgPagnF/f97cg3A==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   ignore@5.3.2:
-    resolution:
-      {
-        integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==,
-      }
-    engines: { node: '>= 4' }
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
 
   ignore@7.0.5:
-    resolution:
-      {
-        integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==,
-      }
-    engines: { node: '>= 4' }
+    resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
+    engines: {node: '>= 4'}
 
   import-fresh@3.3.1:
-    resolution:
-      {
-        integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
 
   import-local@3.1.0:
-    resolution:
-      {
-        integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==}
+    engines: {node: '>=8'}
     hasBin: true
 
   import-local@3.2.0:
-    resolution:
-      {
-        integrity: sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==}
+    engines: {node: '>=8'}
     hasBin: true
 
   imurmurhash@0.1.4:
-    resolution:
-      {
-        integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==,
-      }
-    engines: { node: '>=0.8.19' }
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
+    engines: {node: '>=0.8.19'}
 
   indent-string@4.0.0:
-    resolution:
-      {
-        integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==}
+    engines: {node: '>=8'}
 
   inflection@3.0.2:
-    resolution:
-      {
-        integrity: sha512-+Bg3+kg+J6JUWn8J6bzFmOWkTQ6L/NHfDRSYU+EVvuKHDxUDHAXgqixHfVlzuBQaPOTac8hn43aPhMNk6rMe3g==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-+Bg3+kg+J6JUWn8J6bzFmOWkTQ6L/NHfDRSYU+EVvuKHDxUDHAXgqixHfVlzuBQaPOTac8hn43aPhMNk6rMe3g==}
+    engines: {node: '>=18.0.0'}
 
   inflekt@0.7.1:
-    resolution:
-      {
-        integrity: sha512-iNsb7kpQeo7HUHayGI8Wbe9PC1TIJu15VfJU/Q6MADuhZh6skVifGrDsJp8t45xXg84ywvqnZwh4B6lN34nVTw==,
-      }
+    resolution: {integrity: sha512-iNsb7kpQeo7HUHayGI8Wbe9PC1TIJu15VfJU/Q6MADuhZh6skVifGrDsJp8t45xXg84ywvqnZwh4B6lN34nVTw==}
 
   inflight@1.0.6:
-    resolution:
-      {
-        integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==,
-      }
+    resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
     deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.
 
   inherits@2.0.4:
-    resolution:
-      {
-        integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==,
-      }
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
   ini@1.3.8:
-    resolution:
-      {
-        integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==,
-      }
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
 
   ini@4.1.3:
-    resolution:
-      {
-        integrity: sha512-X7rqawQBvfdjS10YU1y1YVreA3SsLrW9dX2CewP2EbBJM4ypVNLDkO5y04gejPwKIY9lR+7r9gn3rFPt/kmWFg==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-X7rqawQBvfdjS10YU1y1YVreA3SsLrW9dX2CewP2EbBJM4ypVNLDkO5y04gejPwKIY9lR+7r9gn3rFPt/kmWFg==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   init-package-json@6.0.3:
-    resolution:
-      {
-        integrity: sha512-Zfeb5ol+H+eqJWHTaGca9BovufyGeIfr4zaaBorPmJBMrJ+KBnN+kQx2ZtXdsotUTgldHmHQV44xvUWOUA7E2w==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-Zfeb5ol+H+eqJWHTaGca9BovufyGeIfr4zaaBorPmJBMrJ+KBnN+kQx2ZtXdsotUTgldHmHQV44xvUWOUA7E2w==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   inquirer@8.2.7:
-    resolution:
-      {
-        integrity: sha512-UjOaSel/iddGZJ5xP/Eixh6dY1XghiBw4XK13rCCIJcJfyhhoul/7KhLLUGtebEj6GDYM6Vnx/mVsjx2L/mFIA==,
-      }
-    engines: { node: '>=12.0.0' }
+    resolution: {integrity: sha512-UjOaSel/iddGZJ5xP/Eixh6dY1XghiBw4XK13rCCIJcJfyhhoul/7KhLLUGtebEj6GDYM6Vnx/mVsjx2L/mFIA==}
+    engines: {node: '>=12.0.0'}
 
   inquirerer@4.9.1:
-    resolution:
-      {
-        integrity: sha512-RXgbivwNs9luseSHnjIcJ05A8VRGcdCQuLjyWWBmI1zwyorkSzCw4KyK8634a5KrbbXehSJHBE3rIrtgJJiBEQ==,
-      }
+    resolution: {integrity: sha512-RXgbivwNs9luseSHnjIcJ05A8VRGcdCQuLjyWWBmI1zwyorkSzCw4KyK8634a5KrbbXehSJHBE3rIrtgJJiBEQ==}
 
   interpret@3.1.1:
-    resolution:
-      {
-        integrity: sha512-6xwYfHbajpoF0xLW+iwLkhwgvLoZDfjYfoFNu8ftMoXINzwuymNLd9u/KmwtdT2GbR+/Cz66otEGEVVUHX9QLQ==,
-      }
-    engines: { node: '>=10.13.0' }
+    resolution: {integrity: sha512-6xwYfHbajpoF0xLW+iwLkhwgvLoZDfjYfoFNu8ftMoXINzwuymNLd9u/KmwtdT2GbR+/Cz66otEGEVVUHX9QLQ==}
+    engines: {node: '>=10.13.0'}
 
   ip-address@10.1.0:
-    resolution:
-      {
-        integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==,
-      }
-    engines: { node: '>= 12' }
+    resolution: {integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==}
+    engines: {node: '>= 12'}
 
   ipaddr.js@1.9.1:
-    resolution:
-      {
-        integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==,
-      }
-    engines: { node: '>= 0.10' }
+    resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
+    engines: {node: '>= 0.10'}
 
   ipv6-normalize@1.0.1:
-    resolution:
-      {
-        integrity: sha512-Bm6H79i01DjgGTCWjUuCjJ6QDo1HB96PT/xCYuyJUP9WFbVDrLSbG4EZCvOCun2rNswZb0c3e4Jt/ws795esHA==,
-      }
+    resolution: {integrity: sha512-Bm6H79i01DjgGTCWjUuCjJ6QDo1HB96PT/xCYuyJUP9WFbVDrLSbG4EZCvOCun2rNswZb0c3e4Jt/ws795esHA==}
 
   is-arrayish@0.2.1:
-    resolution:
-      {
-        integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==,
-      }
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
 
   is-binary-path@2.1.0:
-    resolution:
-      {
-        integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
 
   is-ci@3.0.1:
-    resolution:
-      {
-        integrity: sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==,
-      }
+    resolution: {integrity: sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==}
     hasBin: true
 
   is-core-module@2.16.1:
-    resolution:
-      {
-        integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
+    engines: {node: '>= 0.4'}
 
   is-docker@2.2.1:
-    resolution:
-      {
-        integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
+    engines: {node: '>=8'}
     hasBin: true
 
   is-extglob@2.1.1:
-    resolution:
-      {
-        integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
 
   is-fullwidth-code-point@3.0.0:
-    resolution:
-      {
-        integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
 
   is-generator-fn@2.1.0:
-    resolution:
-      {
-        integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==}
+    engines: {node: '>=6'}
 
   is-glob@4.0.3:
-    resolution:
-      {
-        integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
 
   is-interactive@1.0.0:
-    resolution:
-      {
-        integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==}
+    engines: {node: '>=8'}
 
   is-lambda@1.0.1:
-    resolution:
-      {
-        integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==,
-      }
+    resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==}
 
   is-number@7.0.0:
-    resolution:
-      {
-        integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==,
-      }
-    engines: { node: '>=0.12.0' }
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
 
   is-obj@2.0.0:
-    resolution:
-      {
-        integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==}
+    engines: {node: '>=8'}
 
   is-plain-obj@1.1.0:
-    resolution:
-      {
-        integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==}
+    engines: {node: '>=0.10.0'}
 
   is-plain-object@2.0.4:
-    resolution:
-      {
-        integrity: sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==}
+    engines: {node: '>=0.10.0'}
 
   is-potential-custom-element-name@1.0.1:
-    resolution:
-      {
-        integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==,
-      }
+    resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
 
   is-primitive@3.0.1:
-    resolution:
-      {
-        integrity: sha512-GljRxhWvlCNRfZyORiH77FwdFwGcMO620o37EOYC0ORWdq+WYNVqW0w2Juzew4M+L81l6/QS3t5gkkihyRqv9w==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-GljRxhWvlCNRfZyORiH77FwdFwGcMO620o37EOYC0ORWdq+WYNVqW0w2Juzew4M+L81l6/QS3t5gkkihyRqv9w==}
+    engines: {node: '>=0.10.0'}
 
   is-promise@4.0.0:
-    resolution:
-      {
-        integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==,
-      }
+    resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
 
   is-ssh@1.4.1:
-    resolution:
-      {
-        integrity: sha512-JNeu1wQsHjyHgn9NcWTaXq6zWSR6hqE0++zhfZlkFBbScNkyvxCdeV8sRkSBaeLKxmbpR21brail63ACNxJ0Tg==,
-      }
+    resolution: {integrity: sha512-JNeu1wQsHjyHgn9NcWTaXq6zWSR6hqE0++zhfZlkFBbScNkyvxCdeV8sRkSBaeLKxmbpR21brail63ACNxJ0Tg==}
 
   is-stream@2.0.0:
-    resolution:
-      {
-        integrity: sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==}
+    engines: {node: '>=8'}
 
   is-stream@2.0.1:
-    resolution:
-      {
-        integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
 
   is-text-path@1.0.1:
-    resolution:
-      {
-        integrity: sha512-xFuJpne9oFz5qDaodwmmG08e3CawH/2ZV8Qqza1Ko7Sk8POWbkRdwIoAWVhqvq0XeUzANEhKo2n0IXUGBm7A/w==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-xFuJpne9oFz5qDaodwmmG08e3CawH/2ZV8Qqza1Ko7Sk8POWbkRdwIoAWVhqvq0XeUzANEhKo2n0IXUGBm7A/w==}
+    engines: {node: '>=0.10.0'}
 
   is-unicode-supported@0.1.0:
-    resolution:
-      {
-        integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==}
+    engines: {node: '>=10'}
 
   is-wsl@2.2.0:
-    resolution:
-      {
-        integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
+    engines: {node: '>=8'}
 
   isarray@0.0.1:
-    resolution:
-      {
-        integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==,
-      }
+    resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==}
 
   isarray@1.0.0:
-    resolution:
-      {
-        integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==,
-      }
+    resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
 
   isexe@2.0.0:
-    resolution:
-      {
-        integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==,
-      }
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
   isexe@3.1.1:
-    resolution:
-      {
-        integrity: sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==,
-      }
-    engines: { node: '>=16' }
+    resolution: {integrity: sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==}
+    engines: {node: '>=16'}
 
   isobject@3.0.1:
-    resolution:
-      {
-        integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==}
+    engines: {node: '>=0.10.0'}
 
   istanbul-lib-coverage@3.2.2:
-    resolution:
-      {
-        integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
+    engines: {node: '>=8'}
 
   istanbul-lib-instrument@6.0.3:
-    resolution:
-      {
-        integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==}
+    engines: {node: '>=10'}
 
   istanbul-lib-report@3.0.1:
-    resolution:
-      {
-        integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
+    engines: {node: '>=10'}
 
   istanbul-lib-source-maps@5.0.6:
-    resolution:
-      {
-        integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==}
+    engines: {node: '>=10'}
 
   istanbul-reports@3.2.0:
-    resolution:
-      {
-        integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
+    engines: {node: '>=8'}
 
   iterall@1.3.0:
-    resolution:
-      {
-        integrity: sha512-QZ9qOMdF+QLHxy1QIpUHUU1D5pS2CG2P69LF6L6CPjPYA/XMOmKV3PZpawHoAjHNyB0swdVTRxdYT4tbBbxqwg==,
-      }
+    resolution: {integrity: sha512-QZ9qOMdF+QLHxy1QIpUHUU1D5pS2CG2P69LF6L6CPjPYA/XMOmKV3PZpawHoAjHNyB0swdVTRxdYT4tbBbxqwg==}
 
   jackspeak@3.4.3:
-    resolution:
-      {
-        integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==,
-      }
+    resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
 
   jackspeak@4.2.3:
-    resolution:
-      {
-        integrity: sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==,
-      }
-    engines: { node: 20 || >=22 }
+    resolution: {integrity: sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==}
+    engines: {node: 20 || >=22}
 
   jake@10.9.4:
-    resolution:
-      {
-        integrity: sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==}
+    engines: {node: '>=10'}
     hasBin: true
 
   jest-changed-files@30.4.1:
-    resolution:
-      {
-        integrity: sha512-IuctmYrxi21iOSOaIXpJWalHyPAsVv0GeBHKDn8C1CA4W5htHn7INL+wdnL4Bo0+olEndvAFkmb++tIQJG+vvg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-IuctmYrxi21iOSOaIXpJWalHyPAsVv0GeBHKDn8C1CA4W5htHn7INL+wdnL4Bo0+olEndvAFkmb++tIQJG+vvg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-circus@30.4.2:
-    resolution:
-      {
-        integrity: sha512-rvHH7VlY6LgbJXJTQ87GW62g1FntOtbhh0zT+v04kC+pgL6aBKyYINXxWukCpj3dcIBMw5/XUbtDS9dU9JTXeQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-rvHH7VlY6LgbJXJTQ87GW62g1FntOtbhh0zT+v04kC+pgL6aBKyYINXxWukCpj3dcIBMw5/XUbtDS9dU9JTXeQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-cli@30.4.2:
-    resolution:
-      {
-        integrity: sha512-jfA2ocvVHMXS2QijrJ0d31ektP+d/W0T5RpcTX2Pq+3sVqHlsXVCM2+FmwpL+bdY8OfHpIg9xMxLF17Zg0U49Q==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-jfA2ocvVHMXS2QijrJ0d31ektP+d/W0T5RpcTX2Pq+3sVqHlsXVCM2+FmwpL+bdY8OfHpIg9xMxLF17Zg0U49Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
@@ -11141,11 +8216,8 @@ packages:
         optional: true
 
   jest-config@30.4.2:
-    resolution:
-      {
-        integrity: sha512-rNHAShJQqQwFNoL0hbf3BphSBOWnpOUAKvidLS/AjNVLPfoj5mSf4jQMfW3cYOs6hXeZC7nF7mDHaBnbxELOzg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-rNHAShJQqQwFNoL0hbf3BphSBOWnpOUAKvidLS/AjNVLPfoj5mSf4jQMfW3cYOs6hXeZC7nF7mDHaBnbxELOzg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       '@types/node': '*'
       esbuild-register: '>=3.4.0'
@@ -11159,46 +8231,28 @@ packages:
         optional: true
 
   jest-diff@29.7.0:
-    resolution:
-      {
-        integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==,
-      }
-    engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 }
+    resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
   jest-diff@30.2.0:
-    resolution:
-      {
-        integrity: sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-diff@30.4.1:
-    resolution:
-      {
-        integrity: sha512-CRpFK0RtLriVDGcPPAnR6HMVI8bSR2jnUIgralhauzYQZIb4RH9AtEInTuQr65LmmGggGcRT6HIASxwqsVsmlA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-CRpFK0RtLriVDGcPPAnR6HMVI8bSR2jnUIgralhauzYQZIb4RH9AtEInTuQr65LmmGggGcRT6HIASxwqsVsmlA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-docblock@30.4.0:
-    resolution:
-      {
-        integrity: sha512-ZPMabUZCx5MpbZ2eBYSvZ0J8fvo3dR9oM+eeUpb3aKNQFuS2tu3Duw1TNlMoP8k3WQgKGJuhcMFvwcVuq6T7oA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-ZPMabUZCx5MpbZ2eBYSvZ0J8fvo3dR9oM+eeUpb3aKNQFuS2tu3Duw1TNlMoP8k3WQgKGJuhcMFvwcVuq6T7oA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-each@30.4.1:
-    resolution:
-      {
-        integrity: sha512-/8MJbH6fuj48TstjrMf+u/pd06Qezz5xOXvZA6442heNOWr8bdeoGZX2d9fCn028CoMgYmroH9//zky5GfyYmA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-/8MJbH6fuj48TstjrMf+u/pd06Qezz5xOXvZA6442heNOWr8bdeoGZX2d9fCn028CoMgYmroH9//zky5GfyYmA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-environment-jsdom@30.4.1:
-    resolution:
-      {
-        integrity: sha512-o3nfaN4zej7qgk2X0j8Jhq/S9nAVKs2xK3QeQxeHVvpkEPxaA1yxDGydR+iVI7zPy7Cp62Aq2h3Ja46QvfWHGA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-o3nfaN4zej7qgk2X0j8Jhq/S9nAVKs2xK3QeQxeHVvpkEPxaA1yxDGydR+iVI7zPy7Cp62Aq2h3Ja46QvfWHGA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     peerDependencies:
       canvas: ^3.0.0
     peerDependenciesMeta:
@@ -11206,88 +8260,52 @@ packages:
         optional: true
 
   jest-environment-node@30.4.1:
-    resolution:
-      {
-        integrity: sha512-4FZYVOk85hz2AyT6BbarKy9u37g6DbrDyCdFhsnDdXqyrueYQvB+0zO4f/kqLCRD0BsPRXPMNJeQwihKZV8naw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-4FZYVOk85hz2AyT6BbarKy9u37g6DbrDyCdFhsnDdXqyrueYQvB+0zO4f/kqLCRD0BsPRXPMNJeQwihKZV8naw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-get-type@29.6.3:
-    resolution:
-      {
-        integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==,
-      }
-    engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 }
+    resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
   jest-haste-map@30.4.1:
-    resolution:
-      {
-        integrity: sha512-rFrcONd8jeFsyw+Z9CrScJgglRf2+NFmNam8dKu7n+SoHqNYT47mn0DdEcVUZJpvh7Iz6/si7f7yUH7GJHVgnw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-rFrcONd8jeFsyw+Z9CrScJgglRf2+NFmNam8dKu7n+SoHqNYT47mn0DdEcVUZJpvh7Iz6/si7f7yUH7GJHVgnw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-in-case@1.0.2:
-    resolution:
-      {
-        integrity: sha512-2DE6Gdwnh5jkCYTePWoQinF+zne3lCADibXoYJEt8PS84JaRug0CyAOrEgzMxbzln3YcSY2PBeru7ct4tbflYA==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-2DE6Gdwnh5jkCYTePWoQinF+zne3lCADibXoYJEt8PS84JaRug0CyAOrEgzMxbzln3YcSY2PBeru7ct4tbflYA==}
+    engines: {node: '>=4'}
 
   jest-leak-detector@30.4.1:
-    resolution:
-      {
-        integrity: sha512-IpmyiioeHxiWDhesHnUFmOxcTzwCwKpgACgWajtAP+nYQXiY7DakTxB6Bx9JFiRMljr0AX1PvnQdaU1KFoz6NQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-IpmyiioeHxiWDhesHnUFmOxcTzwCwKpgACgWajtAP+nYQXiY7DakTxB6Bx9JFiRMljr0AX1PvnQdaU1KFoz6NQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-matcher-utils@30.2.0:
-    resolution:
-      {
-        integrity: sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-matcher-utils@30.4.1:
-    resolution:
-      {
-        integrity: sha512-zvYfX5CaeEkFrrLS9suWe9rvJrm9J1Iv3ua8kIBv9GEPzcnsfBf0bob37la7s67fs0nlBC3EuvkOLnXQKxtx4A==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-zvYfX5CaeEkFrrLS9suWe9rvJrm9J1Iv3ua8kIBv9GEPzcnsfBf0bob37la7s67fs0nlBC3EuvkOLnXQKxtx4A==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-message-util@30.2.0:
-    resolution:
-      {
-        integrity: sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-message-util@30.4.1:
-    resolution:
-      {
-        integrity: sha512-kwCKIvq0MCW1HzLoGola9Te6JUdzgV0loyKJ3Qghrkz9i5/RRIHsL95BMQc2HBBhlBKC4j22K9p11TGHH8RBpQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-kwCKIvq0MCW1HzLoGola9Te6JUdzgV0loyKJ3Qghrkz9i5/RRIHsL95BMQc2HBBhlBKC4j22K9p11TGHH8RBpQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-mock@30.2.0:
-    resolution:
-      {
-        integrity: sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-mock@30.4.1:
-    resolution:
-      {
-        integrity: sha512-/i8SVb8/NSB7RfNi8gfqu8gxLV23KaL5EpAttyb9iz8qWRIqXRLflycz/32wXsYkOnaUlx8NAKnJYtpsmXUmfw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-/i8SVb8/NSB7RfNi8gfqu8gxLV23KaL5EpAttyb9iz8qWRIqXRLflycz/32wXsYkOnaUlx8NAKnJYtpsmXUmfw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-pnp-resolver@1.2.3:
-    resolution:
-      {
-        integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==}
+    engines: {node: '>=6'}
     peerDependencies:
       jest-resolve: '*'
     peerDependenciesMeta:
@@ -11295,95 +8313,56 @@ packages:
         optional: true
 
   jest-regex-util@30.0.1:
-    resolution:
-      {
-        integrity: sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-regex-util@30.4.0:
-    resolution:
-      {
-        integrity: sha512-mWlvLviKIgIQ8VCuM1xRdD0TWp3zlzionlmDBjuXVBs+VkmXq6FgW9T4Emr7oGz/Rk6feDCGyiugolcQEyp3mg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-mWlvLviKIgIQ8VCuM1xRdD0TWp3zlzionlmDBjuXVBs+VkmXq6FgW9T4Emr7oGz/Rk6feDCGyiugolcQEyp3mg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-resolve-dependencies@30.4.2:
-    resolution:
-      {
-        integrity: sha512-gDiVh1I+GxYzz9oXlyw+1wv6VOYX1WYxMOfjsA3iGKePV2oxmbHhwxfkALxNxYy1ciw6APWwkW2zZONwP97aEQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-gDiVh1I+GxYzz9oXlyw+1wv6VOYX1WYxMOfjsA3iGKePV2oxmbHhwxfkALxNxYy1ciw6APWwkW2zZONwP97aEQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-resolve@30.4.1:
-    resolution:
-      {
-        integrity: sha512-Zry8Yq/yJcNAZ7dJ5F2heic8AheXvbFZ7XI5V+h28nrYZ7Qoyy4dItq8OodjnYD270mvX+ZudmrNV9cysqhW5Q==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-Zry8Yq/yJcNAZ7dJ5F2heic8AheXvbFZ7XI5V+h28nrYZ7Qoyy4dItq8OodjnYD270mvX+ZudmrNV9cysqhW5Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-runner@30.4.2:
-    resolution:
-      {
-        integrity: sha512-2dw0PslVYXxffXGpLo+Ejad+KcI1Qkjn7f4X4619gf21oCUmL+SPfjqIa/losUem3yEOvfNZe/F1HWUcNpODcg==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-2dw0PslVYXxffXGpLo+Ejad+KcI1Qkjn7f4X4619gf21oCUmL+SPfjqIa/losUem3yEOvfNZe/F1HWUcNpODcg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-runtime@30.4.2:
-    resolution:
-      {
-        integrity: sha512-3/5e8iPz2k/VLqlr8DgTftYyLUv8Su3FkCAO2/Od81UsUTpSxOrS6O5x5KkoQwyUjmpYyDJKeyAvg2T2nvpNkQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-3/5e8iPz2k/VLqlr8DgTftYyLUv8Su3FkCAO2/Od81UsUTpSxOrS6O5x5KkoQwyUjmpYyDJKeyAvg2T2nvpNkQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-snapshot@30.4.1:
-    resolution:
-      {
-        integrity: sha512-tEOkkfOMppUyeiHwjZswOQ3lcnoTnws/q5FnGIaeIh/jmoU0ZlgMYRR8sTlTj+nNGCoJ0RDq6SfxGxCsyMTPmw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-tEOkkfOMppUyeiHwjZswOQ3lcnoTnws/q5FnGIaeIh/jmoU0ZlgMYRR8sTlTj+nNGCoJ0RDq6SfxGxCsyMTPmw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-util@30.2.0:
-    resolution:
-      {
-        integrity: sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-util@30.4.1:
-    resolution:
-      {
-        integrity: sha512-vjQb1sACEiv13DKJMDToJpzVW0joCsIQrmbg0fi7CyOOt+g9jTuQl2A216pWRBYhOVt53XbL/2LbMKg1BECWOw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-vjQb1sACEiv13DKJMDToJpzVW0joCsIQrmbg0fi7CyOOt+g9jTuQl2A216pWRBYhOVt53XbL/2LbMKg1BECWOw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-validate@30.4.1:
-    resolution:
-      {
-        integrity: sha512-PDWi4SOwLnwqNDfHZjOcsEFyZ4fc/2W2gVL3DEoyqnB6jCQMLRtfBong8s6omIw3lI0HWOus12xfnFmQtjW3fw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-PDWi4SOwLnwqNDfHZjOcsEFyZ4fc/2W2gVL3DEoyqnB6jCQMLRtfBong8s6omIw3lI0HWOus12xfnFmQtjW3fw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-watcher@30.4.1:
-    resolution:
-      {
-        integrity: sha512-/l9UonmvCwjHH7d2h3iAwIloLc1H0S8mJZ/LNK3i86hqwPAz8otUJjP9MfYtz9Tt77Su5FD2xGjZn8d31IZHlw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-/l9UonmvCwjHH7d2h3iAwIloLc1H0S8mJZ/LNK3i86hqwPAz8otUJjP9MfYtz9Tt77Su5FD2xGjZn8d31IZHlw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest-worker@30.4.1:
-    resolution:
-      {
-        integrity: sha512-SHynN/q/QD++iNyvMdy+WMmbCGk8jIsNcRxycXbWubSOhvo6T+j2afcfUSl+3hYsiBebOTo0cT7c2H7CXugu1g==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-SHynN/q/QD++iNyvMdy+WMmbCGk8jIsNcRxycXbWubSOhvo6T+j2afcfUSl+3hYsiBebOTo0cT7c2H7CXugu1g==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   jest@30.4.2:
-    resolution:
-      {
-        integrity: sha512-Yi1jqNC/Oq0N4hBgNH/YvBpP1P57QqundgytzYqy3yqAa7NZPNjSoi4SGbRAXDMdBzNE6xBCi5U7RgfrvMEUVQ==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-Yi1jqNC/Oq0N4hBgNH/YvBpP1P57QqundgytzYqy3yqAa7NZPNjSoi4SGbRAXDMdBzNE6xBCi5U7RgfrvMEUVQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
     hasBin: true
     peerDependencies:
       node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
@@ -11392,66 +8371,39 @@ packages:
         optional: true
 
   jiti@2.7.0:
-    resolution:
-      {
-        integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==,
-      }
+    resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==}
     hasBin: true
 
   js-beautify@1.15.4:
-    resolution:
-      {
-        integrity: sha512-9/KXeZUKKJwqCXUdBxFJ3vPh467OCckSBmYDwSK/EtV090K+iMJ7zx2S3HLVDIWFQdqMIsZWbnaGiba18aWhaA==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-9/KXeZUKKJwqCXUdBxFJ3vPh467OCckSBmYDwSK/EtV090K+iMJ7zx2S3HLVDIWFQdqMIsZWbnaGiba18aWhaA==}
+    engines: {node: '>=14'}
     hasBin: true
 
   js-cookie@3.0.5:
-    resolution:
-      {
-        integrity: sha512-cEiJEAEoIbWfCZYKWhVwFuvPX1gETRYPw6LlaTKoxD3s2AkXzkCjnp6h0V77ozyqj0jakteJ4YqDJT830+lVGw==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-cEiJEAEoIbWfCZYKWhVwFuvPX1gETRYPw6LlaTKoxD3s2AkXzkCjnp6h0V77ozyqj0jakteJ4YqDJT830+lVGw==}
+    engines: {node: '>=14'}
 
   js-sha3@0.8.0:
-    resolution:
-      {
-        integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==,
-      }
+    resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==}
 
   js-tokens@4.0.0:
-    resolution:
-      {
-        integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==,
-      }
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
   js-yaml@3.14.2:
-    resolution:
-      {
-        integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==,
-      }
+    resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
     hasBin: true
 
   js-yaml@4.1.0:
-    resolution:
-      {
-        integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==,
-      }
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
     hasBin: true
 
   js-yaml@4.1.1:
-    resolution:
-      {
-        integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==,
-      }
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
     hasBin: true
 
   jsdom@26.1.0:
-    resolution:
-      {
-        integrity: sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==}
+    engines: {node: '>=18'}
     peerDependencies:
       canvas: ^3.0.0
     peerDependenciesMeta:
@@ -11459,532 +8411,289 @@ packages:
         optional: true
 
   jsesc@3.1.0:
-    resolution:
-      {
-        integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
+    engines: {node: '>=6'}
     hasBin: true
 
   json-buffer@3.0.1:
-    resolution:
-      {
-        integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==,
-      }
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
 
   json-parse-better-errors@1.0.2:
-    resolution:
-      {
-        integrity: sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==,
-      }
+    resolution: {integrity: sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==}
 
   json-parse-even-better-errors@2.3.1:
-    resolution:
-      {
-        integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==,
-      }
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
 
   json-parse-even-better-errors@3.0.2:
-    resolution:
-      {
-        integrity: sha512-fi0NG4bPjCHunUJffmLd0gxssIgkNmArMvis4iNah6Owg1MCJjWhEcDLmsK6iGkJq3tHwbDkTlce70/tmXN4cQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-fi0NG4bPjCHunUJffmLd0gxssIgkNmArMvis4iNah6Owg1MCJjWhEcDLmsK6iGkJq3tHwbDkTlce70/tmXN4cQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   json-schema-traverse@0.4.1:
-    resolution:
-      {
-        integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==,
-      }
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
 
   json-schema-traverse@1.0.0:
-    resolution:
-      {
-        integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==,
-      }
+    resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
 
   json-stable-stringify-without-jsonify@1.0.1:
-    resolution:
-      {
-        integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==,
-      }
+    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
 
   json-stringify-nice@1.1.4:
-    resolution:
-      {
-        integrity: sha512-5Z5RFW63yxReJ7vANgW6eZFGWaQvnPE3WNmZoOJrSkGju2etKA2L5rrOa1sm877TVTFt57A80BH1bArcmlLfPw==,
-      }
+    resolution: {integrity: sha512-5Z5RFW63yxReJ7vANgW6eZFGWaQvnPE3WNmZoOJrSkGju2etKA2L5rrOa1sm877TVTFt57A80BH1bArcmlLfPw==}
 
   json-stringify-safe@5.0.1:
-    resolution:
-      {
-        integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==,
-      }
+    resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==}
 
   json5@2.2.3:
-    resolution:
-      {
-        integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
+    engines: {node: '>=6'}
     hasBin: true
 
   jsonc-parser@3.2.0:
-    resolution:
-      {
-        integrity: sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==,
-      }
+    resolution: {integrity: sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==}
 
   jsonc-parser@3.3.1:
-    resolution:
-      {
-        integrity: sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==,
-      }
+    resolution: {integrity: sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==}
 
   jsonfile@6.2.0:
-    resolution:
-      {
-        integrity: sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==,
-      }
+    resolution: {integrity: sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==}
 
   jsonparse@1.3.1:
-    resolution:
-      {
-        integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==,
-      }
-    engines: { '0': node >= 0.2.0 }
+    resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==}
+    engines: {'0': node >= 0.2.0}
 
   jsonwebtoken@9.0.3:
-    resolution:
-      {
-        integrity: sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==,
-      }
-    engines: { node: '>=12', npm: '>=6' }
+    resolution: {integrity: sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==}
+    engines: {node: '>=12', npm: '>=6'}
 
   juice@7.0.0:
-    resolution:
-      {
-        integrity: sha512-AjKQX31KKN+uJs+zaf+GW8mBO/f/0NqSh2moTMyvwBY+4/lXIYTU8D8I2h6BAV3Xnz6GGsbalUyFqbYMe+Vh+Q==,
-      }
-    engines: { node: '>=10.0.0' }
+    resolution: {integrity: sha512-AjKQX31KKN+uJs+zaf+GW8mBO/f/0NqSh2moTMyvwBY+4/lXIYTU8D8I2h6BAV3Xnz6GGsbalUyFqbYMe+Vh+Q==}
+    engines: {node: '>=10.0.0'}
     hasBin: true
 
   just-diff-apply@5.5.0:
-    resolution:
-      {
-        integrity: sha512-OYTthRfSh55WOItVqwpefPtNt2VdKsq5AnAK6apdtR6yCH8pr0CmSr710J0Mf+WdQy7K/OzMy7K2MgAfdQURDw==,
-      }
+    resolution: {integrity: sha512-OYTthRfSh55WOItVqwpefPtNt2VdKsq5AnAK6apdtR6yCH8pr0CmSr710J0Mf+WdQy7K/OzMy7K2MgAfdQURDw==}
 
   just-diff@6.0.2:
-    resolution:
-      {
-        integrity: sha512-S59eriX5u3/QhMNq3v/gm8Kd0w8OS6Tz2FS1NG4blv+z0MuQcBRJyFWjdovM0Rad4/P4aUPFtnkNjMjyMlMSYA==,
-      }
+    resolution: {integrity: sha512-S59eriX5u3/QhMNq3v/gm8Kd0w8OS6Tz2FS1NG4blv+z0MuQcBRJyFWjdovM0Rad4/P4aUPFtnkNjMjyMlMSYA==}
 
   jwa@2.0.1:
-    resolution:
-      {
-        integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==,
-      }
+    resolution: {integrity: sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==}
 
   jws@4.0.1:
-    resolution:
-      {
-        integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==,
-      }
+    resolution: {integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==}
 
   keyv@4.5.4:
-    resolution:
-      {
-        integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==,
-      }
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
   kind-of@6.0.3:
-    resolution:
-      {
-        integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
+    engines: {node: '>=0.10.0'}
 
   komoji@0.9.0:
-    resolution:
-      {
-        integrity: sha512-mbAwXYrQgSE9r618CzW7BHvQfKmDyvPoJFPzaWimEVfcaTyE9aqCvf5RbOwzP16ranN/4rmAuAme1GMrWRZ/sQ==,
-      }
+    resolution: {integrity: sha512-mbAwXYrQgSE9r618CzW7BHvQfKmDyvPoJFPzaWimEVfcaTyE9aqCvf5RbOwzP16ranN/4rmAuAme1GMrWRZ/sQ==}
 
   lerna@8.2.4:
-    resolution:
-      {
-        integrity: sha512-0gaVWDIVT7fLfprfwpYcQajb7dBJv3EGavjG7zvJ+TmGx3/wovl5GklnSwM2/WeE0Z2wrIz7ndWhBcDUHVjOcQ==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-0gaVWDIVT7fLfprfwpYcQajb7dBJv3EGavjG7zvJ+TmGx3/wovl5GklnSwM2/WeE0Z2wrIz7ndWhBcDUHVjOcQ==}
+    engines: {node: '>=18.0.0'}
     hasBin: true
 
   leven@3.1.0:
-    resolution:
-      {
-        integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==}
+    engines: {node: '>=6'}
 
   levn@0.4.1:
-    resolution:
-      {
-        integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==,
-      }
-    engines: { node: '>= 0.8.0' }
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
 
   libnpmaccess@8.0.6:
-    resolution:
-      {
-        integrity: sha512-uM8DHDEfYG6G5gVivVl+yQd4pH3uRclHC59lzIbSvy7b5FEwR+mU49Zq1jEyRtRFv7+M99mUW9S0wL/4laT4lw==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-uM8DHDEfYG6G5gVivVl+yQd4pH3uRclHC59lzIbSvy7b5FEwR+mU49Zq1jEyRtRFv7+M99mUW9S0wL/4laT4lw==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   libnpmpublish@9.0.9:
-    resolution:
-      {
-        integrity: sha512-26zzwoBNAvX9AWOPiqqF6FG4HrSCPsHFkQm7nT+xU1ggAujL/eae81RnCv4CJ2In9q9fh10B88sYSzKCUh/Ghg==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-26zzwoBNAvX9AWOPiqqF6FG4HrSCPsHFkQm7nT+xU1ggAujL/eae81RnCv4CJ2In9q9fh10B88sYSzKCUh/Ghg==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   libpg-query@17.7.3:
-    resolution:
-      {
-        integrity: sha512-lHKBvoWRsXt/9bJxpAeFxkLu0CA6tELusqy3o1z6/DwGXSETxhKJDaNlNdrNV8msvXDLBhpg/4RE/fKKs5rYFA==,
-      }
+    resolution: {integrity: sha512-lHKBvoWRsXt/9bJxpAeFxkLu0CA6tELusqy3o1z6/DwGXSETxhKJDaNlNdrNV8msvXDLBhpg/4RE/fKKs5rYFA==}
 
   lines-and-columns@1.2.4:
-    resolution:
-      {
-        integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==,
-      }
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
   lines-and-columns@2.0.3:
-    resolution:
-      {
-        integrity: sha512-cNOjgCnLB+FnvWWtyRTzmB3POJ+cXxTA81LoW7u8JdmhfXzriropYwpjShnz1QLLWsQwY7nIxoDmcPTwphDK9w==,
-      }
-    engines: { node: ^12.20.0 || ^14.13.1 || >=16.0.0 }
+    resolution: {integrity: sha512-cNOjgCnLB+FnvWWtyRTzmB3POJ+cXxTA81LoW7u8JdmhfXzriropYwpjShnz1QLLWsQwY7nIxoDmcPTwphDK9w==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
   linkify-it@5.0.0:
-    resolution:
-      {
-        integrity: sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==,
-      }
+    resolution: {integrity: sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==}
 
   load-json-file@4.0.0:
-    resolution:
-      {
-        integrity: sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==}
+    engines: {node: '>=4'}
 
   load-json-file@6.2.0:
-    resolution:
-      {
-        integrity: sha512-gUD/epcRms75Cw8RT1pUdHugZYM5ce64ucs2GEISABwkRsOQr0q2wm/MV2TKThycIe5e0ytRweW2RZxclogCdQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-gUD/epcRms75Cw8RT1pUdHugZYM5ce64ucs2GEISABwkRsOQr0q2wm/MV2TKThycIe5e0ytRweW2RZxclogCdQ==}
+    engines: {node: '>=8'}
 
   locate-path@2.0.0:
-    resolution:
-      {
-        integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==}
+    engines: {node: '>=4'}
 
   locate-path@5.0.0:
-    resolution:
-      {
-        integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
+    engines: {node: '>=8'}
 
   locate-path@6.0.0:
-    resolution:
-      {
-        integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
 
   lodash.includes@4.3.0:
-    resolution:
-      {
-        integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==,
-      }
+    resolution: {integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==}
 
   lodash.isboolean@3.0.3:
-    resolution:
-      {
-        integrity: sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==,
-      }
+    resolution: {integrity: sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==}
 
   lodash.isinteger@4.0.4:
-    resolution:
-      {
-        integrity: sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==,
-      }
+    resolution: {integrity: sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==}
 
   lodash.ismatch@4.4.0:
-    resolution:
-      {
-        integrity: sha512-fPMfXjGQEV9Xsq/8MTSgUf255gawYRbjwMyDbcvDhXgV7enSZA0hynz6vMPnpAb5iONEzBHBPsT+0zes5Z301g==,
-      }
+    resolution: {integrity: sha512-fPMfXjGQEV9Xsq/8MTSgUf255gawYRbjwMyDbcvDhXgV7enSZA0hynz6vMPnpAb5iONEzBHBPsT+0zes5Z301g==}
 
   lodash.isnumber@3.0.3:
-    resolution:
-      {
-        integrity: sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==,
-      }
+    resolution: {integrity: sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==}
 
   lodash.isplainobject@4.0.6:
-    resolution:
-      {
-        integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==,
-      }
+    resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}
 
   lodash.isstring@4.0.1:
-    resolution:
-      {
-        integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==,
-      }
+    resolution: {integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==}
 
   lodash.memoize@4.1.2:
-    resolution:
-      {
-        integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==,
-      }
+    resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==}
 
   lodash.merge@4.6.2:
-    resolution:
-      {
-        integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==,
-      }
+    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
 
   lodash.once@4.1.1:
-    resolution:
-      {
-        integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==,
-      }
+    resolution: {integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==}
 
   lodash@4.17.21:
-    resolution:
-      {
-        integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==,
-      }
+    resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
 
   lodash@4.18.1:
-    resolution:
-      {
-        integrity: sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==,
-      }
+    resolution: {integrity: sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==}
 
   log-symbols@4.1.0:
-    resolution:
-      {
-        integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==}
+    engines: {node: '>=10'}
 
   long-timeout@0.1.1:
-    resolution:
-      {
-        integrity: sha512-BFRuQUqc7x2NWxfJBCyUrN8iYUYznzL9JROmRz1gZ6KlOIgmoD+njPVbb+VNn2nGMKggMsK79iUNErillsrx7w==,
-      }
+    resolution: {integrity: sha512-BFRuQUqc7x2NWxfJBCyUrN8iYUYznzL9JROmRz1gZ6KlOIgmoD+njPVbb+VNn2nGMKggMsK79iUNErillsrx7w==}
 
   long@5.3.2:
-    resolution:
-      {
-        integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==,
-      }
+    resolution: {integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==}
 
   loose-envify@1.4.0:
-    resolution:
-      {
-        integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==,
-      }
+    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
     hasBin: true
 
   lower-case@1.1.4:
-    resolution:
-      {
-        integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==,
-      }
+    resolution: {integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==}
 
   lru-cache@10.4.3:
-    resolution:
-      {
-        integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==,
-      }
+    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
   lru-cache@11.2.7:
-    resolution:
-      {
-        integrity: sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==,
-      }
-    engines: { node: 20 || >=22 }
+    resolution: {integrity: sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==}
+    engines: {node: 20 || >=22}
 
   lru-cache@5.1.1:
-    resolution:
-      {
-        integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==,
-      }
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
 
   lru-cache@6.0.0:
-    resolution:
-      {
-        integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
+    engines: {node: '>=10'}
 
   luxon@3.7.2:
-    resolution:
-      {
-        integrity: sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==}
+    engines: {node: '>=12'}
 
   lz-string@1.5.0:
-    resolution:
-      {
-        integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==,
-      }
+    resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==}
     hasBin: true
 
   mailgun.js@10.4.0:
-    resolution:
-      {
-        integrity: sha512-YrdaZEAJwwjXGBTfZTNQ1LM7tmkdUaz2NpZEu7+zULcG4Wrlhd7cWSNZW0bxT3bP48k5N0mZWz8C2f9gc2+Geg==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-YrdaZEAJwwjXGBTfZTNQ1LM7tmkdUaz2NpZEu7+zULcG4Wrlhd7cWSNZW0bxT3bP48k5N0mZWz8C2f9gc2+Geg==}
+    engines: {node: '>=18.0.0'}
 
   makage@0.3.0:
-    resolution:
-      {
-        integrity: sha512-HiBTpSy6iLnI+apv91QTWgBlFiePOCAUXmdYwlVzqkfwtUc0aM1FNu70CLs8xvc2u/R43m3J1SuWprMcKpV+vw==,
-      }
+    resolution: {integrity: sha512-HiBTpSy6iLnI+apv91QTWgBlFiePOCAUXmdYwlVzqkfwtUc0aM1FNu70CLs8xvc2u/R43m3J1SuWprMcKpV+vw==}
     hasBin: true
 
   make-dir@2.1.0:
-    resolution:
-      {
-        integrity: sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==}
+    engines: {node: '>=6'}
 
   make-dir@4.0.0:
-    resolution:
-      {
-        integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
+    engines: {node: '>=10'}
 
   make-error@1.3.6:
-    resolution:
-      {
-        integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==,
-      }
+    resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
 
   make-fetch-happen@13.0.1:
-    resolution:
-      {
-        integrity: sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   makeerror@1.0.12:
-    resolution:
-      {
-        integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==,
-      }
+    resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==}
 
   map-obj@1.0.1:
-    resolution:
-      {
-        integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==}
+    engines: {node: '>=0.10.0'}
 
   map-obj@4.3.0:
-    resolution:
-      {
-        integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==}
+    engines: {node: '>=8'}
 
   markdown-it@14.1.1:
-    resolution:
-      {
-        integrity: sha512-BuU2qnTti9YKgK5N+IeMubp14ZUKUUw7yeJbkjtosvHiP0AZ5c8IAgEMk79D0eC8F23r4Ac/q8cAIFdm2FtyoA==,
-      }
+    resolution: {integrity: sha512-BuU2qnTti9YKgK5N+IeMubp14ZUKUUw7yeJbkjtosvHiP0AZ5c8IAgEMk79D0eC8F23r4Ac/q8cAIFdm2FtyoA==}
     hasBin: true
 
   match-sorter@6.3.4:
-    resolution:
-      {
-        integrity: sha512-jfZW7cWS5y/1xswZo8VBOdudUiSd9nifYRWphc9M5D/ee4w4AoXLgBEdRbgVaxbMuagBPeUC5y2Hi8DO6o9aDg==,
-      }
+    resolution: {integrity: sha512-jfZW7cWS5y/1xswZo8VBOdudUiSd9nifYRWphc9M5D/ee4w4AoXLgBEdRbgVaxbMuagBPeUC5y2Hi8DO6o9aDg==}
 
   math-intrinsics@1.1.0:
-    resolution:
-      {
-        integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
 
   mdurl@2.0.0:
-    resolution:
-      {
-        integrity: sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==,
-      }
+    resolution: {integrity: sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==}
 
   media-typer@1.1.0:
-    resolution:
-      {
-        integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
+    engines: {node: '>= 0.8'}
 
   mensch@0.3.4:
-    resolution:
-      {
-        integrity: sha512-IAeFvcOnV9V0Yk+bFhYR07O3yNina9ANIN5MoXBKYJ/RLYPurd2d0yw14MDhpr9/momp0WofT1bPUh3hkzdi/g==,
-      }
+    resolution: {integrity: sha512-IAeFvcOnV9V0Yk+bFhYR07O3yNina9ANIN5MoXBKYJ/RLYPurd2d0yw14MDhpr9/momp0WofT1bPUh3hkzdi/g==}
 
   meow@8.1.2:
-    resolution:
-      {
-        integrity: sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==}
+    engines: {node: '>=10'}
 
   merge-descriptors@2.0.0:
-    resolution:
-      {
-        integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
+    engines: {node: '>=18'}
 
   merge-stream@2.0.0:
-    resolution:
-      {
-        integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==,
-      }
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
 
   merge2@1.4.1:
-    resolution:
-      {
-        integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
 
   meros@1.3.2:
-    resolution:
-      {
-        integrity: sha512-Q3mobPbvEx7XbwhnC1J1r60+5H6EZyNccdzSz0eGexJRwouUtTZxPVRGdqKtxlpD84ScK4+tIGldkqDtCKdI0A==,
-      }
-    engines: { node: '>=13' }
+    resolution: {integrity: sha512-Q3mobPbvEx7XbwhnC1J1r60+5H6EZyNccdzSz0eGexJRwouUtTZxPVRGdqKtxlpD84ScK4+tIGldkqDtCKdI0A==}
+    engines: {node: '>=13'}
     peerDependencies:
       '@types/node': '>=13'
     peerDependenciesMeta:
@@ -11992,572 +8701,314 @@ packages:
         optional: true
 
   methods@1.1.2:
-    resolution:
-      {
-        integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
+    engines: {node: '>= 0.6'}
 
   micromatch@4.0.8:
-    resolution:
-      {
-        integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==,
-      }
-    engines: { node: '>=8.6' }
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
 
   microseconds@0.2.0:
-    resolution:
-      {
-        integrity: sha512-n7DHHMjR1avBbSpsTBj6fmMGh2AGrifVV4e+WYc3Q9lO+xnSZ3NyhcBND3vzzatt05LFhoKFRxrIyklmLlUtyA==,
-      }
+    resolution: {integrity: sha512-n7DHHMjR1avBbSpsTBj6fmMGh2AGrifVV4e+WYc3Q9lO+xnSZ3NyhcBND3vzzatt05LFhoKFRxrIyklmLlUtyA==}
 
   mime-db@1.52.0:
-    resolution:
-      {
-        integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
+    engines: {node: '>= 0.6'}
 
   mime-db@1.54.0:
-    resolution:
-      {
-        integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==}
+    engines: {node: '>= 0.6'}
 
   mime-types@2.1.35:
-    resolution:
-      {
-        integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
+    engines: {node: '>= 0.6'}
 
   mime-types@3.0.2:
-    resolution:
-      {
-        integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==}
+    engines: {node: '>=18'}
 
   mime@2.6.0:
-    resolution:
-      {
-        integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==,
-      }
-    engines: { node: '>=4.0.0' }
+    resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==}
+    engines: {node: '>=4.0.0'}
     hasBin: true
 
   mimic-fn@2.1.0:
-    resolution:
-      {
-        integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
 
   min-indent@1.0.1:
-    resolution:
-      {
-        integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==}
+    engines: {node: '>=4'}
 
   minimatch@10.2.4:
-    resolution:
-      {
-        integrity: sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==,
-      }
-    engines: { node: 18 || 20 || >=22 }
+    resolution: {integrity: sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==}
+    engines: {node: 18 || 20 || >=22}
 
   minimatch@10.2.5:
-    resolution:
-      {
-        integrity: sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==,
-      }
-    engines: { node: 18 || 20 || >=22 }
+    resolution: {integrity: sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==}
+    engines: {node: 18 || 20 || >=22}
 
   minimatch@3.0.5:
-    resolution:
-      {
-        integrity: sha512-tUpxzX0VAzJHjLu0xUfFv1gwVp9ba3IOuRAVH2EGuRW8a5emA2FlACLqiT/lDVtS1W+TGNwqz3sWaNyLgDJWuw==,
-      }
+    resolution: {integrity: sha512-tUpxzX0VAzJHjLu0xUfFv1gwVp9ba3IOuRAVH2EGuRW8a5emA2FlACLqiT/lDVtS1W+TGNwqz3sWaNyLgDJWuw==}
 
   minimatch@3.1.2:
-    resolution:
-      {
-        integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==,
-      }
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
 
   minimatch@3.1.5:
-    resolution:
-      {
-        integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==,
-      }
+    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
 
   minimatch@5.1.9:
-    resolution:
-      {
-        integrity: sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==}
+    engines: {node: '>=10'}
 
   minimatch@8.0.7:
-    resolution:
-      {
-        integrity: sha512-V+1uQNdzybxa14e/p00HZnQNNcTjnRJjDxg2V8wtkjFctq4M7hXFws4oekyTP0Jebeq7QYtpFyOeBAjc88zvYg==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-V+1uQNdzybxa14e/p00HZnQNNcTjnRJjDxg2V8wtkjFctq4M7hXFws4oekyTP0Jebeq7QYtpFyOeBAjc88zvYg==}
+    engines: {node: '>=16 || 14 >=14.17'}
 
   minimatch@9.0.1:
-    resolution:
-      {
-        integrity: sha512-0jWhJpD/MdhPXwPuiRkCbfYfSKp2qnn2eOc279qI7f+osl/l+prKSrvhg157zSYvx/1nmgn2NqdT6k2Z7zSH9w==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-0jWhJpD/MdhPXwPuiRkCbfYfSKp2qnn2eOc279qI7f+osl/l+prKSrvhg157zSYvx/1nmgn2NqdT6k2Z7zSH9w==}
+    engines: {node: '>=16 || 14 >=14.17'}
 
   minimatch@9.0.3:
-    resolution:
-      {
-        integrity: sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==}
+    engines: {node: '>=16 || 14 >=14.17'}
 
   minimatch@9.0.9:
-    resolution:
-      {
-        integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==}
+    engines: {node: '>=16 || 14 >=14.17'}
 
   minimist-options@4.1.0:
-    resolution:
-      {
-        integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==}
+    engines: {node: '>= 6'}
 
   minimist@1.2.8:
-    resolution:
-      {
-        integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==,
-      }
+    resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
 
   minipass-collect@2.0.1:
-    resolution:
-      {
-        integrity: sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==}
+    engines: {node: '>=16 || 14 >=14.17'}
 
   minipass-fetch@3.0.5:
-    resolution:
-      {
-        integrity: sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   minipass-flush@1.0.5:
-    resolution:
-      {
-        integrity: sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==}
+    engines: {node: '>= 8'}
 
   minipass-pipeline@1.2.4:
-    resolution:
-      {
-        integrity: sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==}
+    engines: {node: '>=8'}
 
   minipass-sized@1.0.3:
-    resolution:
-      {
-        integrity: sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==}
+    engines: {node: '>=8'}
 
   minipass@3.3.6:
-    resolution:
-      {
-        integrity: sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==}
+    engines: {node: '>=8'}
 
   minipass@4.2.8:
-    resolution:
-      {
-        integrity: sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ==}
+    engines: {node: '>=8'}
 
   minipass@5.0.0:
-    resolution:
-      {
-        integrity: sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==}
+    engines: {node: '>=8'}
 
   minipass@7.1.2:
-    resolution:
-      {
-        integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
+    engines: {node: '>=16 || 14 >=14.17'}
 
   minipass@7.1.3:
-    resolution:
-      {
-        integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==,
-      }
-    engines: { node: '>=16 || 14 >=14.17' }
+    resolution: {integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==}
+    engines: {node: '>=16 || 14 >=14.17'}
 
   minizlib@2.1.2:
-    resolution:
-      {
-        integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
+    engines: {node: '>= 8'}
 
   mjml-accordion@4.7.1:
-    resolution:
-      {
-        integrity: sha512-oYwC/CLOUWJ6pRt2saDHj/HytGOHO5B5lKNqUAhKPye5HFNZykKEV5ChmZ2NfGsGU+9BhQ7H5DaCafp4fDmPAg==,
-      }
+    resolution: {integrity: sha512-oYwC/CLOUWJ6pRt2saDHj/HytGOHO5B5lKNqUAhKPye5HFNZykKEV5ChmZ2NfGsGU+9BhQ7H5DaCafp4fDmPAg==}
 
   mjml-body@4.7.1:
-    resolution:
-      {
-        integrity: sha512-JCrkit+kjCfQyKuVyWSOonM2LGs/o3+63R9l2SleFeXf3+0CaKWaZr/Exzvaeo28c+1o3yRqXbJIpD22SEtJfQ==,
-      }
+    resolution: {integrity: sha512-JCrkit+kjCfQyKuVyWSOonM2LGs/o3+63R9l2SleFeXf3+0CaKWaZr/Exzvaeo28c+1o3yRqXbJIpD22SEtJfQ==}
 
   mjml-button@4.7.1:
-    resolution:
-      {
-        integrity: sha512-N3WkTMPOvKw2y6sakt1YfYDbOB8apumm1OApPG6J18CHcrX03BwhHPrdfu1JwlRNGwx4kCDdb6zNCGPwuZxkCg==,
-      }
+    resolution: {integrity: sha512-N3WkTMPOvKw2y6sakt1YfYDbOB8apumm1OApPG6J18CHcrX03BwhHPrdfu1JwlRNGwx4kCDdb6zNCGPwuZxkCg==}
 
   mjml-carousel@4.7.1:
-    resolution:
-      {
-        integrity: sha512-eH3rRyX23ES0BKOn+UUV39+yGNmZVApBVVV0A5znDaNWskCg6/g6ZhEHi4nkWpj+aP2lJKI0HX1nrMfJg0Mxhg==,
-      }
+    resolution: {integrity: sha512-eH3rRyX23ES0BKOn+UUV39+yGNmZVApBVVV0A5znDaNWskCg6/g6ZhEHi4nkWpj+aP2lJKI0HX1nrMfJg0Mxhg==}
 
   mjml-cli@4.7.1:
-    resolution:
-      {
-        integrity: sha512-xzCtJVKYVhGorvTmnbcMUfZlmJdBnu1UBD9A1H8UUBGMNE/Hs9QpHs9PLCMp8JR/uhSu15IgVjhFN0oSVndMRQ==,
-      }
+    resolution: {integrity: sha512-xzCtJVKYVhGorvTmnbcMUfZlmJdBnu1UBD9A1H8UUBGMNE/Hs9QpHs9PLCMp8JR/uhSu15IgVjhFN0oSVndMRQ==}
     hasBin: true
 
   mjml-column@4.7.1:
-    resolution:
-      {
-        integrity: sha512-CGw81TnGiuPR1GblLOez8xeoeAz1SEFjMpqapazjgXUuF5xUxg3qH55Wt4frpXe3VypeZWVYeumr6CwoNaPbKg==,
-      }
+    resolution: {integrity: sha512-CGw81TnGiuPR1GblLOez8xeoeAz1SEFjMpqapazjgXUuF5xUxg3qH55Wt4frpXe3VypeZWVYeumr6CwoNaPbKg==}
 
   mjml-core@4.7.1:
-    resolution:
-      {
-        integrity: sha512-AMACoq/h440m7SM86As8knW0bNQgjNIzsP/cMF6X9RO07GfszgbaWUq/XCaRNi+q8bWvBJSCXbngDJySVc5ALw==,
-      }
+    resolution: {integrity: sha512-AMACoq/h440m7SM86As8knW0bNQgjNIzsP/cMF6X9RO07GfszgbaWUq/XCaRNi+q8bWvBJSCXbngDJySVc5ALw==}
 
   mjml-divider@4.7.1:
-    resolution:
-      {
-        integrity: sha512-7+uCUJdqEr6w8AzpF8lhRheelYEgOwiK0KJGlAQN3LF+h2S1rTPEzEB67qL2x5cU+80kPlxtxoQWImDBy0vXqg==,
-      }
+    resolution: {integrity: sha512-7+uCUJdqEr6w8AzpF8lhRheelYEgOwiK0KJGlAQN3LF+h2S1rTPEzEB67qL2x5cU+80kPlxtxoQWImDBy0vXqg==}
 
   mjml-group@4.7.1:
-    resolution:
-      {
-        integrity: sha512-mAYdhocCzetdhPSws/9/sQ4hcz4kQPX2dNitQmbxNVwoMFYXjp/WcLEfGc5u13Ue7dPfcV6c9lB/Uu5o3NmRvw==,
-      }
+    resolution: {integrity: sha512-mAYdhocCzetdhPSws/9/sQ4hcz4kQPX2dNitQmbxNVwoMFYXjp/WcLEfGc5u13Ue7dPfcV6c9lB/Uu5o3NmRvw==}
 
   mjml-head-attributes@4.7.1:
-    resolution:
-      {
-        integrity: sha512-nB/bQ3I98Dvy/IkI4nqxTCnLonULkIKc8KrieRTrtPkUV3wskBzngpCgnjKvFPbHWiGlwjHDzcFJc7G0uWeqog==,
-      }
+    resolution: {integrity: sha512-nB/bQ3I98Dvy/IkI4nqxTCnLonULkIKc8KrieRTrtPkUV3wskBzngpCgnjKvFPbHWiGlwjHDzcFJc7G0uWeqog==}
 
   mjml-head-breakpoint@4.7.1:
-    resolution:
-      {
-        integrity: sha512-0KB5SweIWDvwHkn4VCUsEhCQgfY/0wkNUnSXNoftaRujv0NQFQfOOH4eINy0NZYfDfrE4WYe08z+olHprp+T2A==,
-      }
+    resolution: {integrity: sha512-0KB5SweIWDvwHkn4VCUsEhCQgfY/0wkNUnSXNoftaRujv0NQFQfOOH4eINy0NZYfDfrE4WYe08z+olHprp+T2A==}
 
   mjml-head-font@4.7.1:
-    resolution:
-      {
-        integrity: sha512-9YGzBcQ2htZ6j266fiLLfzcxqDEDLTvfKtypTjaeRb1w3N8S5wL+/zJA5ZjRL6r39Ij5ZPQSlSDC32KPiwhGkA==,
-      }
+    resolution: {integrity: sha512-9YGzBcQ2htZ6j266fiLLfzcxqDEDLTvfKtypTjaeRb1w3N8S5wL+/zJA5ZjRL6r39Ij5ZPQSlSDC32KPiwhGkA==}
 
   mjml-head-html-attributes@4.7.1:
-    resolution:
-      {
-        integrity: sha512-2TK2nGpq4rGaghbVx2UNm5TXeZ5BTGYEvtSPoYPNu02KRCj6tb+uedAgFXwJpX+ogRfIfPK50ih+9ZMoHwf2IQ==,
-      }
+    resolution: {integrity: sha512-2TK2nGpq4rGaghbVx2UNm5TXeZ5BTGYEvtSPoYPNu02KRCj6tb+uedAgFXwJpX+ogRfIfPK50ih+9ZMoHwf2IQ==}
 
   mjml-head-preview@4.7.1:
-    resolution:
-      {
-        integrity: sha512-UHlvvgldiPDODq/5zKMsmXgRb/ZyKygKDUVQSM5bm3HvpKXeyYxJZazcIGmlGICEqv1ced1WGINhCg72dSfN+Q==,
-      }
+    resolution: {integrity: sha512-UHlvvgldiPDODq/5zKMsmXgRb/ZyKygKDUVQSM5bm3HvpKXeyYxJZazcIGmlGICEqv1ced1WGINhCg72dSfN+Q==}
 
   mjml-head-style@4.7.1:
-    resolution:
-      {
-        integrity: sha512-8Gij99puN1SoOx5tGBjgkh4iCpI+zbwGBiB2Y8VwJrwXQxdJ1Qa902dQP5djoFFG39Bthii/48cS/d1bHigGPQ==,
-      }
+    resolution: {integrity: sha512-8Gij99puN1SoOx5tGBjgkh4iCpI+zbwGBiB2Y8VwJrwXQxdJ1Qa902dQP5djoFFG39Bthii/48cS/d1bHigGPQ==}
 
   mjml-head-title@4.7.1:
-    resolution:
-      {
-        integrity: sha512-vK3r+DApTXw2EoK/fh8dQOsO438Z7Ksy6iBIb7h04x33d4Z41r6+jtgxGXoKFXnjgr8MyLX5HZyyie5obW+hZg==,
-      }
+    resolution: {integrity: sha512-vK3r+DApTXw2EoK/fh8dQOsO438Z7Ksy6iBIb7h04x33d4Z41r6+jtgxGXoKFXnjgr8MyLX5HZyyie5obW+hZg==}
 
   mjml-head@4.7.1:
-    resolution:
-      {
-        integrity: sha512-jUcJ674CT1oT8NTQWTjQQBFZu4yklK0oppfGFJ1cq76ze3isMiyhSnGnOHw6FkjLnZtb3gXXaGKX7UZM+UMk/w==,
-      }
+    resolution: {integrity: sha512-jUcJ674CT1oT8NTQWTjQQBFZu4yklK0oppfGFJ1cq76ze3isMiyhSnGnOHw6FkjLnZtb3gXXaGKX7UZM+UMk/w==}
 
   mjml-hero@4.7.1:
-    resolution:
-      {
-        integrity: sha512-x+29V8zJAs8EV/eTtGbR921pCpitMQOAkyvNANW/3JLDTL2Oio1OYvGPVC3z1wOT9LKuRTxVzNHVt/bBw02CSQ==,
-      }
+    resolution: {integrity: sha512-x+29V8zJAs8EV/eTtGbR921pCpitMQOAkyvNANW/3JLDTL2Oio1OYvGPVC3z1wOT9LKuRTxVzNHVt/bBw02CSQ==}
 
   mjml-image@4.7.1:
-    resolution:
-      {
-        integrity: sha512-l3uRR2jaM0Bpz4ctdWuxQUFgg+ol6Nt+ODOrnHsGMwpmFOh4hTPTky6KaF0LCXxYmGbI0FoGBna+hVNnkBsQCA==,
-      }
+    resolution: {integrity: sha512-l3uRR2jaM0Bpz4ctdWuxQUFgg+ol6Nt+ODOrnHsGMwpmFOh4hTPTky6KaF0LCXxYmGbI0FoGBna+hVNnkBsQCA==}
 
   mjml-migrate@4.7.1:
-    resolution:
-      {
-        integrity: sha512-RgrJ9fHg6iRHC2H4pjRDWilBQ1eTH2jRu1ayDplbnepGoql83vLZaYaWc5Q+J+NsaNI16x+bgNB3fQdBiK+mng==,
-      }
+    resolution: {integrity: sha512-RgrJ9fHg6iRHC2H4pjRDWilBQ1eTH2jRu1ayDplbnepGoql83vLZaYaWc5Q+J+NsaNI16x+bgNB3fQdBiK+mng==}
     hasBin: true
 
   mjml-navbar@4.7.1:
-    resolution:
-      {
-        integrity: sha512-awdu8zT7xhS+9aCVunqtocUs8KA2xb+UhJ8UGbxVBpYbTNj3rCL9aWUXqWVwMk1la+3ypCkFuDuTl6dIoWPWlA==,
-      }
+    resolution: {integrity: sha512-awdu8zT7xhS+9aCVunqtocUs8KA2xb+UhJ8UGbxVBpYbTNj3rCL9aWUXqWVwMk1la+3ypCkFuDuTl6dIoWPWlA==}
 
   mjml-parser-xml@4.7.1:
-    resolution:
-      {
-        integrity: sha512-UWfuRpN45k3GUEv2yl8n5Uf98Tg6FyCsyRnqZGo83mgZzlJRDYTdKII9RjZM646/S8+Q8e9qxi3AsL00j6sZsQ==,
-      }
+    resolution: {integrity: sha512-UWfuRpN45k3GUEv2yl8n5Uf98Tg6FyCsyRnqZGo83mgZzlJRDYTdKII9RjZM646/S8+Q8e9qxi3AsL00j6sZsQ==}
 
   mjml-raw@4.7.1:
-    resolution:
-      {
-        integrity: sha512-mCQFEXINTkC8i7ydP1Km99e0FaZTeu79AoYnTBAILd4QO+RuD3n/PimBGrcGrOUex0JIKa2jyVQOcSCBuG4WpA==,
-      }
+    resolution: {integrity: sha512-mCQFEXINTkC8i7ydP1Km99e0FaZTeu79AoYnTBAILd4QO+RuD3n/PimBGrcGrOUex0JIKa2jyVQOcSCBuG4WpA==}
 
   mjml-react@1.0.59:
-    resolution:
-      {
-        integrity: sha512-W1ULnMlxJHE0kNpInu+u3CHr6+QcvhoLJ2ov93Pzt2A1wXAv4CJ9T/P5h/BhZn8vvCXgGizcwHv8sfANfQONVw==,
-      }
+    resolution: {integrity: sha512-W1ULnMlxJHE0kNpInu+u3CHr6+QcvhoLJ2ov93Pzt2A1wXAv4CJ9T/P5h/BhZn8vvCXgGizcwHv8sfANfQONVw==}
     peerDependencies:
       mjml: ^4.1.2
       react: ^16.4.0
       react-dom: ^16.4.0
 
   mjml-section@4.7.1:
-    resolution:
-      {
-        integrity: sha512-PlhCMsl/bpFwwgQGUopi9OgOGWgRPpEJVKE8hk4He8GXzbfIuDj4DZ9QJSkwIoZ0fZtcgz11Wwb19i9BZcozVw==,
-      }
+    resolution: {integrity: sha512-PlhCMsl/bpFwwgQGUopi9OgOGWgRPpEJVKE8hk4He8GXzbfIuDj4DZ9QJSkwIoZ0fZtcgz11Wwb19i9BZcozVw==}
 
   mjml-social@4.7.1:
-    resolution:
-      {
-        integrity: sha512-tN/6V3m59izO9rqWpUokHxhwkk2GHkltzIlhI936hAJHh8hFyEO6+ZwQBZm738G00qgfICmQvX5FNq4upkCYjw==,
-      }
+    resolution: {integrity: sha512-tN/6V3m59izO9rqWpUokHxhwkk2GHkltzIlhI936hAJHh8hFyEO6+ZwQBZm738G00qgfICmQvX5FNq4upkCYjw==}
 
   mjml-spacer@4.7.1:
-    resolution:
-      {
-        integrity: sha512-gQu1+nA9YGnoolfNPvzfVe/RJ8WqS8ho0hthlhiLOC2RnEnmqH7HHSzCFXm4OeN0VgvDQsM7mfYQGl82O58Y+g==,
-      }
+    resolution: {integrity: sha512-gQu1+nA9YGnoolfNPvzfVe/RJ8WqS8ho0hthlhiLOC2RnEnmqH7HHSzCFXm4OeN0VgvDQsM7mfYQGl82O58Y+g==}
 
   mjml-table@4.7.1:
-    resolution:
-      {
-        integrity: sha512-rPkOtufMiVreb7I7vXk6rDm9i1DXncODnM5JJNhA9Z1dAQwXiz6V5904gAi2cEYfe0M2m0XQ8P5ZCtvqxGkfGA==,
-      }
+    resolution: {integrity: sha512-rPkOtufMiVreb7I7vXk6rDm9i1DXncODnM5JJNhA9Z1dAQwXiz6V5904gAi2cEYfe0M2m0XQ8P5ZCtvqxGkfGA==}
 
   mjml-text@4.7.1:
-    resolution:
-      {
-        integrity: sha512-hrjxbY59v6hu/Pn0NO+6TMlrdAlRa3M7GVALx/YWYV3hi59zjYfot8Au7Xq64XdcbcI4eiBVbP/AVr8w03HsOw==,
-      }
+    resolution: {integrity: sha512-hrjxbY59v6hu/Pn0NO+6TMlrdAlRa3M7GVALx/YWYV3hi59zjYfot8Au7Xq64XdcbcI4eiBVbP/AVr8w03HsOw==}
 
   mjml-validator@4.7.1:
-    resolution:
-      {
-        integrity: sha512-Qxubbz5WE182iLSTd/XRuezMr6UE7/u73grDCw0bTIcQsaTAIkWQn2tBI3jj0chWOw+sxwK2C6zPm9B0Cv7BGA==,
-      }
+    resolution: {integrity: sha512-Qxubbz5WE182iLSTd/XRuezMr6UE7/u73grDCw0bTIcQsaTAIkWQn2tBI3jj0chWOw+sxwK2C6zPm9B0Cv7BGA==}
 
   mjml-wrapper@4.7.1:
-    resolution:
-      {
-        integrity: sha512-6i+ZATUyqIO5YBnx+RFKZ3+6mg3iOCS/EdXGYZSonZ/EHqlt+RJa3fG2BB4dacXqAjghfl6Lk+bLoR47P3xYIQ==,
-      }
+    resolution: {integrity: sha512-6i+ZATUyqIO5YBnx+RFKZ3+6mg3iOCS/EdXGYZSonZ/EHqlt+RJa3fG2BB4dacXqAjghfl6Lk+bLoR47P3xYIQ==}
 
   mjml@4.7.1:
-    resolution:
-      {
-        integrity: sha512-nwMrmhTI+Aeh9Gav9LHX/i8k8yDi/QpX5h535BlT5oP4NaAUmyxP/UeYUn9yxtPcIzDlM5ullFnRv/71jyHpkQ==,
-      }
+    resolution: {integrity: sha512-nwMrmhTI+Aeh9Gav9LHX/i8k8yDi/QpX5h535BlT5oP4NaAUmyxP/UeYUn9yxtPcIzDlM5ullFnRv/71jyHpkQ==}
     hasBin: true
 
   mkdirp@1.0.4:
-    resolution:
-      {
-        integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
+    engines: {node: '>=10'}
     hasBin: true
 
   mock-req@0.2.0:
-    resolution:
-      {
-        integrity: sha512-IUuwS0W5GjoPyjhuXPQJXpaHfHW7UYFRia8Cchm/xRuyDDclpSQdEoakt3krOpSYvgVlQsbnf0ePDsTRDfp7Dg==,
-      }
+    resolution: {integrity: sha512-IUuwS0W5GjoPyjhuXPQJXpaHfHW7UYFRia8Cchm/xRuyDDclpSQdEoakt3krOpSYvgVlQsbnf0ePDsTRDfp7Dg==}
 
   modify-values@1.0.1:
-    resolution:
-      {
-        integrity: sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==}
+    engines: {node: '>=0.10.0'}
 
   monaco-editor@0.52.2:
-    resolution:
-      {
-        integrity: sha512-GEQWEZmfkOGLdd3XK8ryrfWz3AIP8YymVXiPHEdewrUq7mh0qrKrfHLNCXcbB6sTnMLnOZ3ztSiKcciFUkIJwQ==,
-      }
+    resolution: {integrity: sha512-GEQWEZmfkOGLdd3XK8ryrfWz3AIP8YymVXiPHEdewrUq7mh0qrKrfHLNCXcbB6sTnMLnOZ3ztSiKcciFUkIJwQ==}
 
   monaco-graphql@1.7.3:
-    resolution:
-      {
-        integrity: sha512-6LAIcg/vT2NGLjHnT+5iIZONsZCaCuz2orbg7qD/u4Ry9R7rDotLh0HAzIF/yKdzEA5fTZC+TofSx2O+Zi+0ow==,
-      }
+    resolution: {integrity: sha512-6LAIcg/vT2NGLjHnT+5iIZONsZCaCuz2orbg7qD/u4Ry9R7rDotLh0HAzIF/yKdzEA5fTZC+TofSx2O+Zi+0ow==}
     peerDependencies:
       graphql: 16.13.0
       monaco-editor: '>= 0.20.0 < 0.53'
       prettier: ^2.8.0 || ^3.0.0
 
   motion-dom@12.36.0:
-    resolution:
-      {
-        integrity: sha512-Ep1pq8P88rGJ75om8lTCA13zqd7ywPGwCqwuWwin6BKc0hMLkVfcS6qKlRqEo2+t0DwoUcgGJfXwaiFn4AOcQA==,
-      }
+    resolution: {integrity: sha512-Ep1pq8P88rGJ75om8lTCA13zqd7ywPGwCqwuWwin6BKc0hMLkVfcS6qKlRqEo2+t0DwoUcgGJfXwaiFn4AOcQA==}
 
   motion-utils@12.36.0:
-    resolution:
-      {
-        integrity: sha512-eHWisygbiwVvf6PZ1vhaHCLamvkSbPIeAYxWUuL3a2PD/TROgE7FvfHWTIH4vMl798QLfMw15nRqIaRDXTlYRg==,
-      }
+    resolution: {integrity: sha512-eHWisygbiwVvf6PZ1vhaHCLamvkSbPIeAYxWUuL3a2PD/TROgE7FvfHWTIH4vMl798QLfMw15nRqIaRDXTlYRg==}
 
   ms@2.1.3:
-    resolution:
-      {
-        integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==,
-      }
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
   multimatch@5.0.0:
-    resolution:
-      {
-        integrity: sha512-ypMKuglUrZUD99Tk2bUQ+xNQj43lPEfAeX2o9cTteAmShXy2VHDJpuwu1o0xqoKCt9jLVAvwyFKdLTPXKAfJyA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-ypMKuglUrZUD99Tk2bUQ+xNQj43lPEfAeX2o9cTteAmShXy2VHDJpuwu1o0xqoKCt9jLVAvwyFKdLTPXKAfJyA==}
+    engines: {node: '>=10'}
 
   mute-stream@0.0.8:
-    resolution:
-      {
-        integrity: sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==,
-      }
+    resolution: {integrity: sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==}
 
   mute-stream@1.0.0:
-    resolution:
-      {
-        integrity: sha512-avsJQhyd+680gKXyG/sQc0nXaC6rBkPOfyHYcFb9+hdkqQkR9bdnkJ0AMZhke0oesPqIO+mFFJ+IdBc7mst4IA==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-avsJQhyd+680gKXyG/sQc0nXaC6rBkPOfyHYcFb9+hdkqQkR9bdnkJ0AMZhke0oesPqIO+mFFJ+IdBc7mst4IA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   nano-time@1.0.0:
-    resolution:
-      {
-        integrity: sha512-flnngywOoQ0lLQOTRNexn2gGSNuM9bKj9RZAWSzhQ+UJYaAFG9bac4DW9VHjUAzrOaIcajHybCTHe/bkvozQqA==,
-      }
+    resolution: {integrity: sha512-flnngywOoQ0lLQOTRNexn2gGSNuM9bKj9RZAWSzhQ+UJYaAFG9bac4DW9VHjUAzrOaIcajHybCTHe/bkvozQqA==}
 
   nanoid@3.3.11:
-    resolution:
-      {
-        integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==,
-      }
-    engines: { node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1 }
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
   napi-postinstall@0.3.4:
-    resolution:
-      {
-        integrity: sha512-PHI5f1O0EP5xJ9gQmFGMS6IZcrVvTjpXjz7Na41gTE7eE2hK11lg04CECCYEEjdc17EV4DO+fkGEtt7TpTaTiQ==,
-      }
-    engines: { node: ^12.20.0 || ^14.18.0 || >=16.0.0 }
+    resolution: {integrity: sha512-PHI5f1O0EP5xJ9gQmFGMS6IZcrVvTjpXjz7Na41gTE7eE2hK11lg04CECCYEEjdc17EV4DO+fkGEtt7TpTaTiQ==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
     hasBin: true
 
   natural-compare@1.4.0:
-    resolution:
-      {
-        integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==,
-      }
+    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
 
   negotiator@0.6.4:
-    resolution:
-      {
-        integrity: sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==}
+    engines: {node: '>= 0.6'}
 
   negotiator@1.0.0:
-    resolution:
-      {
-        integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
+    engines: {node: '>= 0.6'}
 
   neo-async@2.6.2:
-    resolution:
-      {
-        integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==,
-      }
+    resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
 
   nested-obj@0.2.2:
-    resolution:
-      {
-        integrity: sha512-M1etu+T6Ai9Bo06L3K3nWD0ytZWltggBGsrxJlOGvMNGlCA4fokUVlbPKoWzsiiRX+PXq6Cb1xFEn4chiyC7MQ==,
-      }
+    resolution: {integrity: sha512-M1etu+T6Ai9Bo06L3K3nWD0ytZWltggBGsrxJlOGvMNGlCA4fokUVlbPKoWzsiiRX+PXq6Cb1xFEn4chiyC7MQ==}
 
   no-case@2.3.2:
-    resolution:
-      {
-        integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==,
-      }
+    resolution: {integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==}
 
   node-fetch@2.6.7:
-    resolution:
-      {
-        integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==,
-      }
-    engines: { node: 4.x || >=6.0.0 }
+    resolution: {integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==}
+    engines: {node: 4.x || >=6.0.0}
     peerDependencies:
       encoding: ^0.1.0
     peerDependenciesMeta:
@@ -12565,11 +9016,8 @@ packages:
         optional: true
 
   node-fetch@2.7.0:
-    resolution:
-      {
-        integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==,
-      }
-    engines: { node: 4.x || >=6.0.0 }
+    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
+    engines: {node: 4.x || >=6.0.0}
     peerDependencies:
       encoding: ^0.1.0
     peerDependenciesMeta:
@@ -12577,186 +9025,105 @@ packages:
         optional: true
 
   node-gyp@10.3.1:
-    resolution:
-      {
-        integrity: sha512-Pp3nFHBThHzVtNY7U6JfPjvT/DTE8+o/4xKsLQtBoU+j2HLsGlhcfzflAoUreaJbNmYnX+LlLi0qjV8kpyO6xQ==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-Pp3nFHBThHzVtNY7U6JfPjvT/DTE8+o/4xKsLQtBoU+j2HLsGlhcfzflAoUreaJbNmYnX+LlLi0qjV8kpyO6xQ==}
+    engines: {node: ^16.14.0 || >=18.0.0}
     hasBin: true
 
   node-int64@0.4.0:
-    resolution:
-      {
-        integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==,
-      }
+    resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
 
   node-machine-id@1.1.12:
-    resolution:
-      {
-        integrity: sha512-QNABxbrPa3qEIfrE6GOJ7BYIuignnJw7iQ2YPbc3Nla1HzRJjXzZOiikfF8m7eAMfichLt3M4VgLOetqgDmgGQ==,
-      }
+    resolution: {integrity: sha512-QNABxbrPa3qEIfrE6GOJ7BYIuignnJw7iQ2YPbc3Nla1HzRJjXzZOiikfF8m7eAMfichLt3M4VgLOetqgDmgGQ==}
 
   node-releases@2.0.27:
-    resolution:
-      {
-        integrity: sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==,
-      }
+    resolution: {integrity: sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==}
 
   node-schedule@2.1.1:
-    resolution:
-      {
-        integrity: sha512-OXdegQq03OmXEjt2hZP33W2YPs/E5BcFQks46+G2gAxs4gHOIVD1u7EqlYLYSKsaIpyKCK9Gbk0ta1/gjRSMRQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-OXdegQq03OmXEjt2hZP33W2YPs/E5BcFQks46+G2gAxs4gHOIVD1u7EqlYLYSKsaIpyKCK9Gbk0ta1/gjRSMRQ==}
+    engines: {node: '>=6'}
 
   nodemailer@6.10.1:
-    resolution:
-      {
-        integrity: sha512-Z+iLaBGVaSjbIzQ4pX6XV41HrooLsQ10ZWPUehGmuantvzWoDVBnmsdUcOIDM1t+yPor5pDhVlDESgOMEGxhHA==,
-      }
-    engines: { node: '>=6.0.0' }
+    resolution: {integrity: sha512-Z+iLaBGVaSjbIzQ4pX6XV41HrooLsQ10ZWPUehGmuantvzWoDVBnmsdUcOIDM1t+yPor5pDhVlDESgOMEGxhHA==}
+    engines: {node: '>=6.0.0'}
 
   nodemailer@8.0.5:
-    resolution:
-      {
-        integrity: sha512-0PF8Yb1yZuQfQbq+5/pZJrtF6WQcjTd5/S4JOHs9PGFxuTqoB/icwuB44pOdURHJbRKX1PPoJZtY7R4VUoCC8w==,
-      }
-    engines: { node: '>=6.0.0' }
+    resolution: {integrity: sha512-0PF8Yb1yZuQfQbq+5/pZJrtF6WQcjTd5/S4JOHs9PGFxuTqoB/icwuB44pOdURHJbRKX1PPoJZtY7R4VUoCC8w==}
+    engines: {node: '>=6.0.0'}
 
   nodemon@3.1.14:
-    resolution:
-      {
-        integrity: sha512-jakjZi93UtB3jHMWsXL68FXSAosbLfY0In5gtKq3niLSkrWznrVBzXFNOEMJUfc9+Ke7SHWoAZsiMkNP3vq6Jw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-jakjZi93UtB3jHMWsXL68FXSAosbLfY0In5gtKq3niLSkrWznrVBzXFNOEMJUfc9+Ke7SHWoAZsiMkNP3vq6Jw==}
+    engines: {node: '>=10'}
     hasBin: true
 
   noms@0.0.0:
-    resolution:
-      {
-        integrity: sha512-lNDU9VJaOPxUmXcLb+HQFeUgQQPtMI24Gt6hgfuMHRJgMRHMF/qZ4HJD3GDru4sSw9IQl2jPjAYnQrdIeLbwow==,
-      }
+    resolution: {integrity: sha512-lNDU9VJaOPxUmXcLb+HQFeUgQQPtMI24Gt6hgfuMHRJgMRHMF/qZ4HJD3GDru4sSw9IQl2jPjAYnQrdIeLbwow==}
 
   nopt@7.2.1:
-    resolution:
-      {
-        integrity: sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
     hasBin: true
 
   normalize-package-data@2.5.0:
-    resolution:
-      {
-        integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==,
-      }
+    resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
 
   normalize-package-data@3.0.3:
-    resolution:
-      {
-        integrity: sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==}
+    engines: {node: '>=10'}
 
   normalize-package-data@6.0.2:
-    resolution:
-      {
-        integrity: sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   normalize-path@3.0.0:
-    resolution:
-      {
-        integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
+    engines: {node: '>=0.10.0'}
 
   npm-bundled@3.0.1:
-    resolution:
-      {
-        integrity: sha512-+AvaheE/ww1JEwRHOrn4WHNzOxGtVp+adrg2AeZS/7KuxGUYFuBta98wYpfHBbJp6Tg6j1NKSEVHNcfZzJHQwQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-+AvaheE/ww1JEwRHOrn4WHNzOxGtVp+adrg2AeZS/7KuxGUYFuBta98wYpfHBbJp6Tg6j1NKSEVHNcfZzJHQwQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   npm-install-checks@6.3.0:
-    resolution:
-      {
-        integrity: sha512-W29RiK/xtpCGqn6f3ixfRYGk+zRyr+Ew9F2E20BfXxT5/euLdA/Nm7fO7OeTGuAmTs30cpgInyJ0cYe708YTZw==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-W29RiK/xtpCGqn6f3ixfRYGk+zRyr+Ew9F2E20BfXxT5/euLdA/Nm7fO7OeTGuAmTs30cpgInyJ0cYe708YTZw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   npm-normalize-package-bin@3.0.1:
-    resolution:
-      {
-        integrity: sha512-dMxCf+zZ+3zeQZXKxmyuCKlIDPGuv8EF940xbkC4kQVDTtqoh6rJFO+JTKSA6/Rwi0getWmtuy4Itup0AMcaDQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-dMxCf+zZ+3zeQZXKxmyuCKlIDPGuv8EF940xbkC4kQVDTtqoh6rJFO+JTKSA6/Rwi0getWmtuy4Itup0AMcaDQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   npm-package-arg@11.0.2:
-    resolution:
-      {
-        integrity: sha512-IGN0IAwmhDJwy13Wc8k+4PEbTPhpJnMtfR53ZbOyjkvmEcLS4nCwp6mvMWjS5sUjeiW3mpx6cHmuhKEu9XmcQw==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-IGN0IAwmhDJwy13Wc8k+4PEbTPhpJnMtfR53ZbOyjkvmEcLS4nCwp6mvMWjS5sUjeiW3mpx6cHmuhKEu9XmcQw==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   npm-packlist@8.0.2:
-    resolution:
-      {
-        integrity: sha512-shYrPFIS/JLP4oQmAwDyk5HcyysKW8/JLTEA32S0Z5TzvpaeeX2yMFfoK1fjEBnCBvVyIB/Jj/GBFdm0wsgzbA==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-shYrPFIS/JLP4oQmAwDyk5HcyysKW8/JLTEA32S0Z5TzvpaeeX2yMFfoK1fjEBnCBvVyIB/Jj/GBFdm0wsgzbA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   npm-pick-manifest@9.1.0:
-    resolution:
-      {
-        integrity: sha512-nkc+3pIIhqHVQr085X9d2JzPzLyjzQS96zbruppqC9aZRm/x8xx6xhI98gHtsfELP2bE+loHq8ZaHFHhe+NauA==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-nkc+3pIIhqHVQr085X9d2JzPzLyjzQS96zbruppqC9aZRm/x8xx6xhI98gHtsfELP2bE+loHq8ZaHFHhe+NauA==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   npm-registry-fetch@17.1.0:
-    resolution:
-      {
-        integrity: sha512-5+bKQRH0J1xG1uZ1zMNvxW0VEyoNWgJpY9UDuluPFLKDfJ9u2JmmjmTJV1srBGQOROfdBMiVvnH2Zvpbm+xkVA==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-5+bKQRH0J1xG1uZ1zMNvxW0VEyoNWgJpY9UDuluPFLKDfJ9u2JmmjmTJV1srBGQOROfdBMiVvnH2Zvpbm+xkVA==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   npm-run-path@4.0.1:
-    resolution:
-      {
-        integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==}
+    engines: {node: '>=8'}
 
   nth-check@1.0.2:
-    resolution:
-      {
-        integrity: sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==,
-      }
+    resolution: {integrity: sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==}
 
   nth-check@2.1.1:
-    resolution:
-      {
-        integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==,
-      }
+    resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==}
 
   nullthrows@1.1.1:
-    resolution:
-      {
-        integrity: sha512-2vPPEi+Z7WqML2jZYddDIfy5Dqb0r2fze2zTxNNknZaFpVHU3mFB3R+DWeJWGVx0ecvttSGlJTI+WG+8Z4cDWw==,
-      }
+    resolution: {integrity: sha512-2vPPEi+Z7WqML2jZYddDIfy5Dqb0r2fze2zTxNNknZaFpVHU3mFB3R+DWeJWGVx0ecvttSGlJTI+WG+8Z4cDWw==}
 
   nwsapi@2.2.24:
-    resolution:
-      {
-        integrity: sha512-7YRhZ3jS45LwmSCT4b2sVFHt/WuovaktDU07QrtOBY2PXskss5a9jfmR9jptyumwXST+rFjrmppMY1KT/yn35A==,
-      }
+    resolution: {integrity: sha512-7YRhZ3jS45LwmSCT4b2sVFHt/WuovaktDU07QrtOBY2PXskss5a9jfmR9jptyumwXST+rFjrmppMY1KT/yn35A==}
 
   nx@20.8.3:
-    resolution:
-      {
-        integrity: sha512-8w815WSMWar3A/LFzwtmEY+E8cVW62lMiFuPDXje+C8O8hFndfvscP56QHNMn2Zdhz3q0+BZUe+se4Em1BKYdA==,
-      }
+    resolution: {integrity: sha512-8w815WSMWar3A/LFzwtmEY+E8cVW62lMiFuPDXje+C8O8hFndfvscP56QHNMn2Zdhz3q0+BZUe+se4Em1BKYdA==}
     hasBin: true
     peerDependencies:
       '@swc-node/register': ^1.8.0
@@ -12768,86 +9135,50 @@ packages:
         optional: true
 
   object-assign@4.1.1:
-    resolution:
-      {
-        integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
 
   object-inspect@1.13.4:
-    resolution:
-      {
-        integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
+    engines: {node: '>= 0.4'}
 
   object-path@0.11.8:
-    resolution:
-      {
-        integrity: sha512-YJjNZrlXJFM42wTBn6zgOJVar9KFJvzx6sTWDte8sWZF//cnjl0BxHNpfZx+ZffXX63A9q0b1zsFiBX4g4X5KA==,
-      }
-    engines: { node: '>= 10.12.0' }
+    resolution: {integrity: sha512-YJjNZrlXJFM42wTBn6zgOJVar9KFJvzx6sTWDte8sWZF//cnjl0BxHNpfZx+ZffXX63A9q0b1zsFiBX4g4X5KA==}
+    engines: {node: '>= 10.12.0'}
 
   oblivious-set@1.0.0:
-    resolution:
-      {
-        integrity: sha512-z+pI07qxo4c2CulUHCDf9lcqDlMSo72N/4rLUpRXf6fu+q8vjt8y0xS+Tlf8NTJDdTXHbdeO1n3MlbctwEoXZw==,
-      }
+    resolution: {integrity: sha512-z+pI07qxo4c2CulUHCDf9lcqDlMSo72N/4rLUpRXf6fu+q8vjt8y0xS+Tlf8NTJDdTXHbdeO1n3MlbctwEoXZw==}
 
   on-finished@2.4.1:
-    resolution:
-      {
-        integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
+    engines: {node: '>= 0.8'}
 
   once@1.4.0:
-    resolution:
-      {
-        integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==,
-      }
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
 
   onetime@5.1.2:
-    resolution:
-      {
-        integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
 
   open@8.4.2:
-    resolution:
-      {
-        integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
+    engines: {node: '>=12'}
 
   optionator@0.9.4:
-    resolution:
-      {
-        integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==,
-      }
-    engines: { node: '>= 0.8.0' }
+    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
+    engines: {node: '>= 0.8.0'}
 
   ora@5.3.0:
-    resolution:
-      {
-        integrity: sha512-zAKMgGXUim0Jyd6CXK9lraBnD3H5yPGBPPOkC23a2BG6hsm4Zu6OQSjQuEtV0BHDf4aKHcUFvJiGRrFuW3MG8g==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-zAKMgGXUim0Jyd6CXK9lraBnD3H5yPGBPPOkC23a2BG6hsm4Zu6OQSjQuEtV0BHDf4aKHcUFvJiGRrFuW3MG8g==}
+    engines: {node: '>=10'}
 
   ora@5.4.1:
-    resolution:
-      {
-        integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==}
+    engines: {node: '>=10'}
 
   oxfmt@0.51.0:
-    resolution:
-      {
-        integrity: sha512-l/AoAnaEOV7Q5/Z9kHOMDehVJnCgYN7wRoooWCTUMBMi16BJhLZqd9cmCnwcVFfVlzkt53zK2KLPFNp8vSsoDg==,
-      }
-    engines: { node: ^20.19.0 || >=22.12.0 }
+    resolution: {integrity: sha512-l/AoAnaEOV7Q5/Z9kHOMDehVJnCgYN7wRoooWCTUMBMi16BJhLZqd9cmCnwcVFfVlzkt53zK2KLPFNp8vSsoDg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
     hasBin: true
     peerDependencies:
       svelte: ^5.0.0
@@ -12856,380 +9187,212 @@ packages:
         optional: true
 
   p-finally@1.0.0:
-    resolution:
-      {
-        integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==}
+    engines: {node: '>=4'}
 
   p-limit@1.3.0:
-    resolution:
-      {
-        integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==}
+    engines: {node: '>=4'}
 
   p-limit@2.3.0:
-    resolution:
-      {
-        integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
 
   p-limit@3.1.0:
-    resolution:
-      {
-        integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
 
   p-locate@2.0.0:
-    resolution:
-      {
-        integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==}
+    engines: {node: '>=4'}
 
   p-locate@4.1.0:
-    resolution:
-      {
-        integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
+    engines: {node: '>=8'}
 
   p-locate@5.0.0:
-    resolution:
-      {
-        integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
 
   p-map-series@2.1.0:
-    resolution:
-      {
-        integrity: sha512-RpYIIK1zXSNEOdwxcfe7FdvGcs7+y5n8rifMhMNWvaxRNMPINJHF5GDeuVxWqnfrcHPSCnp7Oo5yNXHId9Av2Q==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-RpYIIK1zXSNEOdwxcfe7FdvGcs7+y5n8rifMhMNWvaxRNMPINJHF5GDeuVxWqnfrcHPSCnp7Oo5yNXHId9Av2Q==}
+    engines: {node: '>=8'}
 
   p-map@4.0.0:
-    resolution:
-      {
-        integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==}
+    engines: {node: '>=10'}
 
   p-pipe@3.1.0:
-    resolution:
-      {
-        integrity: sha512-08pj8ATpzMR0Y80x50yJHn37NF6vjrqHutASaX5LiH5npS9XPvrUmscd9MF5R4fuYRHOxQR1FfMIlF7AzwoPqw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-08pj8ATpzMR0Y80x50yJHn37NF6vjrqHutASaX5LiH5npS9XPvrUmscd9MF5R4fuYRHOxQR1FfMIlF7AzwoPqw==}
+    engines: {node: '>=8'}
 
   p-queue@6.6.2:
-    resolution:
-      {
-        integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==}
+    engines: {node: '>=8'}
 
   p-reduce@2.1.0:
-    resolution:
-      {
-        integrity: sha512-2USApvnsutq8uoxZBGbbWM0JIYLiEMJ9RlaN7fAzVNb9OZN0SHjjTTfIcb667XynS5Y1VhwDJVDa72TnPzAYWw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-2USApvnsutq8uoxZBGbbWM0JIYLiEMJ9RlaN7fAzVNb9OZN0SHjjTTfIcb667XynS5Y1VhwDJVDa72TnPzAYWw==}
+    engines: {node: '>=8'}
 
   p-timeout@3.2.0:
-    resolution:
-      {
-        integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==}
+    engines: {node: '>=8'}
 
   p-try@1.0.0:
-    resolution:
-      {
-        integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==}
+    engines: {node: '>=4'}
 
   p-try@2.2.0:
-    resolution:
-      {
-        integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
 
   p-waterfall@2.1.1:
-    resolution:
-      {
-        integrity: sha512-RRTnDb2TBG/epPRI2yYXsimO0v3BXC8Yd3ogr1545IaqKK17VGhbWVeGGN+XfCm/08OK8635nH31c8bATkHuSw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-RRTnDb2TBG/epPRI2yYXsimO0v3BXC8Yd3ogr1545IaqKK17VGhbWVeGGN+XfCm/08OK8635nH31c8bATkHuSw==}
+    engines: {node: '>=8'}
 
   package-json-from-dist@1.0.1:
-    resolution:
-      {
-        integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==,
-      }
+    resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
 
   pacote@18.0.6:
-    resolution:
-      {
-        integrity: sha512-+eK3G27SMwsB8kLIuj4h1FUhHtwiEUo21Tw8wNjmvdlpOEr613edv+8FUsTj/4F/VN5ywGE19X18N7CC2EJk6A==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-+eK3G27SMwsB8kLIuj4h1FUhHtwiEUo21Tw8wNjmvdlpOEr613edv+8FUsTj/4F/VN5ywGE19X18N7CC2EJk6A==}
+    engines: {node: ^16.14.0 || >=18.0.0}
     hasBin: true
 
   param-case@2.1.1:
-    resolution:
-      {
-        integrity: sha512-eQE845L6ot89sk2N8liD8HAuH4ca6Vvr7VWAWwt7+kvvG5aBcPmmphQ68JsEG2qa9n1TykS2DLeMt363AAH8/w==,
-      }
+    resolution: {integrity: sha512-eQE845L6ot89sk2N8liD8HAuH4ca6Vvr7VWAWwt7+kvvG5aBcPmmphQ68JsEG2qa9n1TykS2DLeMt363AAH8/w==}
 
   parent-module@1.0.1:
-    resolution:
-      {
-        integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
 
   parse-conflict-json@3.0.1:
-    resolution:
-      {
-        integrity: sha512-01TvEktc68vwbJOtWZluyWeVGWjP+bZwXtPDMQVbBKzbJ/vZBif0L69KH1+cHv1SZ6e0FKLvjyHe8mqsIqYOmw==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-01TvEktc68vwbJOtWZluyWeVGWjP+bZwXtPDMQVbBKzbJ/vZBif0L69KH1+cHv1SZ6e0FKLvjyHe8mqsIqYOmw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   parse-json@4.0.0:
-    resolution:
-      {
-        integrity: sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==}
+    engines: {node: '>=4'}
 
   parse-json@5.2.0:
-    resolution:
-      {
-        integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
 
   parse-package-name@1.0.0:
-    resolution:
-      {
-        integrity: sha512-kBeTUtcj+SkyfaW4+KBe0HtsloBJ/mKTPoxpVdA57GZiPerREsUWJOhVj9anXweFiJkm5y8FG1sxFZkZ0SN6wg==,
-      }
+    resolution: {integrity: sha512-kBeTUtcj+SkyfaW4+KBe0HtsloBJ/mKTPoxpVdA57GZiPerREsUWJOhVj9anXweFiJkm5y8FG1sxFZkZ0SN6wg==}
 
   parse-path@7.1.0:
-    resolution:
-      {
-        integrity: sha512-EuCycjZtfPcjWk7KTksnJ5xPMvWGA/6i4zrLYhRG0hGvC3GPU/jGUj3Cy+ZR0v30duV3e23R95T1lE2+lsndSw==,
-      }
+    resolution: {integrity: sha512-EuCycjZtfPcjWk7KTksnJ5xPMvWGA/6i4zrLYhRG0hGvC3GPU/jGUj3Cy+ZR0v30duV3e23R95T1lE2+lsndSw==}
 
   parse-url@8.1.0:
-    resolution:
-      {
-        integrity: sha512-xDvOoLU5XRrcOZvnI6b8zA6n9O9ejNk/GExuz1yBuWUGn9KA97GI6HTs6u02wKara1CeVmZhH+0TZFdWScR89w==,
-      }
+    resolution: {integrity: sha512-xDvOoLU5XRrcOZvnI6b8zA6n9O9ejNk/GExuz1yBuWUGn9KA97GI6HTs6u02wKara1CeVmZhH+0TZFdWScR89w==}
 
   parse5-htmlparser2-tree-adapter@7.1.0:
-    resolution:
-      {
-        integrity: sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==,
-      }
+    resolution: {integrity: sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==}
 
   parse5-parser-stream@7.1.2:
-    resolution:
-      {
-        integrity: sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==,
-      }
+    resolution: {integrity: sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==}
 
   parse5@3.0.3:
-    resolution:
-      {
-        integrity: sha512-rgO9Zg5LLLkfJF9E6CCmXlSE4UVceloys8JrFqCcHloC3usd/kJCyPDwH2SOlzix2j3xaP9sUX3e8+kvkuleAA==,
-      }
+    resolution: {integrity: sha512-rgO9Zg5LLLkfJF9E6CCmXlSE4UVceloys8JrFqCcHloC3usd/kJCyPDwH2SOlzix2j3xaP9sUX3e8+kvkuleAA==}
 
   parse5@7.3.0:
-    resolution:
-      {
-        integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==,
-      }
+    resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
 
   parseurl@1.3.3:
-    resolution:
-      {
-        integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
+    engines: {node: '>= 0.8'}
 
   path-exists@3.0.0:
-    resolution:
-      {
-        integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==}
+    engines: {node: '>=4'}
 
   path-exists@4.0.0:
-    resolution:
-      {
-        integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
 
   path-expression-matcher@1.5.0:
-    resolution:
-      {
-        integrity: sha512-cbrerZV+6rvdQrrD+iGMcZFEiiSrbv9Tfdkvnusy6y0x0GKBXREFg/Y65GhIfm0tnLntThhzCnfKwp1WRjeCyQ==,
-      }
-    engines: { node: '>=14.0.0' }
+    resolution: {integrity: sha512-cbrerZV+6rvdQrrD+iGMcZFEiiSrbv9Tfdkvnusy6y0x0GKBXREFg/Y65GhIfm0tnLntThhzCnfKwp1WRjeCyQ==}
+    engines: {node: '>=14.0.0'}
 
   path-is-absolute@1.0.1:
-    resolution:
-      {
-        integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==}
+    engines: {node: '>=0.10.0'}
 
   path-key@3.1.1:
-    resolution:
-      {
-        integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
 
   path-parse@1.0.7:
-    resolution:
-      {
-        integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==,
-      }
+    resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
 
   path-scurry@1.11.1:
-    resolution:
-      {
-        integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==,
-      }
-    engines: { node: '>=16 || 14 >=14.18' }
+    resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
+    engines: {node: '>=16 || 14 >=14.18'}
 
   path-scurry@2.0.2:
-    resolution:
-      {
-        integrity: sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==,
-      }
-    engines: { node: 18 || 20 || >=22 }
+    resolution: {integrity: sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==}
+    engines: {node: 18 || 20 || >=22}
 
   path-to-regexp@8.3.0:
-    resolution:
-      {
-        integrity: sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==,
-      }
+    resolution: {integrity: sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==}
 
   path-type@3.0.0:
-    resolution:
-      {
-        integrity: sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==}
+    engines: {node: '>=4'}
 
   pg-cloudflare@1.3.0:
-    resolution:
-      {
-        integrity: sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==,
-      }
+    resolution: {integrity: sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==}
 
   pg-cloudflare@1.4.0:
-    resolution:
-      {
-        integrity: sha512-Vo7z/6rrQYxpNRylp4Tlob2elzbh+N/MOQbxFVWCxS7oEx6jF53GTJFxK2WWpKuBRkmiin4Mt+xofFDjx09R0A==,
-      }
+    resolution: {integrity: sha512-Vo7z/6rrQYxpNRylp4Tlob2elzbh+N/MOQbxFVWCxS7oEx6jF53GTJFxK2WWpKuBRkmiin4Mt+xofFDjx09R0A==}
 
   pg-connection-string@2.12.0:
-    resolution:
-      {
-        integrity: sha512-U7qg+bpswf3Cs5xLzRqbXbQl85ng0mfSV/J0nnA31MCLgvEaAo7CIhmeyrmJpOr7o+zm0rXK+hNnT5l9RHkCkQ==,
-      }
+    resolution: {integrity: sha512-U7qg+bpswf3Cs5xLzRqbXbQl85ng0mfSV/J0nnA31MCLgvEaAo7CIhmeyrmJpOr7o+zm0rXK+hNnT5l9RHkCkQ==}
 
   pg-connection-string@2.13.0:
-    resolution:
-      {
-        integrity: sha512-EMnU9E2fSULdsbErBbMaXJvFeD9B4+nPcM3f+4lsiCR0BHLPrLVjv3DbyM2hgQQviKJaTWIRRTjKjWlHg3p2ig==,
-      }
+    resolution: {integrity: sha512-EMnU9E2fSULdsbErBbMaXJvFeD9B4+nPcM3f+4lsiCR0BHLPrLVjv3DbyM2hgQQviKJaTWIRRTjKjWlHg3p2ig==}
 
   pg-copy-streams@7.0.0:
-    resolution:
-      {
-        integrity: sha512-zBvnY6wtaBRE2ae2xXWOOGMaNVPkXh1vhypAkNSKgMdciJeTyIQAHZaEeRAxUjs/p1El5jgzYmwG5u871Zj3dQ==,
-      }
+    resolution: {integrity: sha512-zBvnY6wtaBRE2ae2xXWOOGMaNVPkXh1vhypAkNSKgMdciJeTyIQAHZaEeRAxUjs/p1El5jgzYmwG5u871Zj3dQ==}
 
   pg-int8@1.0.1:
-    resolution:
-      {
-        integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==,
-      }
-    engines: { node: '>=4.0.0' }
+    resolution: {integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==}
+    engines: {node: '>=4.0.0'}
 
   pg-introspection@1.0.1:
-    resolution:
-      {
-        integrity: sha512-HwxpCEWygpRPfvFf7IVtEPchtjl1Fw0TxzCYXJIQdTEFio/AcGnp2XI5x+LpowbyEa3XgB9L5gvw2D0Jqji4eA==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-HwxpCEWygpRPfvFf7IVtEPchtjl1Fw0TxzCYXJIQdTEFio/AcGnp2XI5x+LpowbyEa3XgB9L5gvw2D0Jqji4eA==}
+    engines: {node: '>=22'}
 
   pg-pool@3.13.0:
-    resolution:
-      {
-        integrity: sha512-gB+R+Xud1gLFuRD/QgOIgGOBE2KCQPaPwkzBBGC9oG69pHTkhQeIuejVIk3/cnDyX39av2AxomQiyPT13WKHQA==,
-      }
+    resolution: {integrity: sha512-gB+R+Xud1gLFuRD/QgOIgGOBE2KCQPaPwkzBBGC9oG69pHTkhQeIuejVIk3/cnDyX39av2AxomQiyPT13WKHQA==}
     peerDependencies:
       pg: '>=8.0'
 
   pg-pool@3.14.0:
-    resolution:
-      {
-        integrity: sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==,
-      }
+    resolution: {integrity: sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==}
     peerDependencies:
       pg: '>=8.0'
 
   pg-proto-parser@1.30.6:
-    resolution:
-      {
-        integrity: sha512-2XwPyl9oz5Pest4ebaovRTTJN8MXaa/XvqMQzKq127fFcl4I1POUgV/FtzHzg/p8FjtO5yHsipeW/kAumzNxxw==,
-      }
+    resolution: {integrity: sha512-2XwPyl9oz5Pest4ebaovRTTJN8MXaa/XvqMQzKq127fFcl4I1POUgV/FtzHzg/p8FjtO5yHsipeW/kAumzNxxw==}
 
   pg-protocol@1.13.0:
-    resolution:
-      {
-        integrity: sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w==,
-      }
+    resolution: {integrity: sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w==}
 
   pg-protocol@1.14.0:
-    resolution:
-      {
-        integrity: sha512-n5taZ1kO3s9ngDTVxsEznOqCyToTgz0FLuPq0B33COy5pPpuWJpY3/2oRBVETuOgzdqRXfWpM9HIhp2LBBT1BA==,
-      }
+    resolution: {integrity: sha512-n5taZ1kO3s9ngDTVxsEznOqCyToTgz0FLuPq0B33COy5pPpuWJpY3/2oRBVETuOgzdqRXfWpM9HIhp2LBBT1BA==}
 
   pg-sql2@5.0.1:
-    resolution:
-      {
-        integrity: sha512-DdOZNUBhuBuGcq3UgUNsYE9FPdPzw9YA1K/WQxutNhC17DA/CImapyamv6lliVvdAVNZ+CWB1z+p7SmSJmkezw==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-DdOZNUBhuBuGcq3UgUNsYE9FPdPzw9YA1K/WQxutNhC17DA/CImapyamv6lliVvdAVNZ+CWB1z+p7SmSJmkezw==}
+    engines: {node: '>=22'}
 
   pg-types@2.2.0:
-    resolution:
-      {
-        integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==}
+    engines: {node: '>=4'}
 
   pg@8.20.0:
-    resolution:
-      {
-        integrity: sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==,
-      }
-    engines: { node: '>= 16.0.0' }
+    resolution: {integrity: sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==}
+    engines: {node: '>= 16.0.0'}
     peerDependencies:
       pg-native: '>=3.0.1'
     peerDependenciesMeta:
@@ -13237,11 +9400,8 @@ packages:
         optional: true
 
   pg@8.21.0:
-    resolution:
-      {
-        integrity: sha512-AUP1EYJuHraQGsVoCQVIcM7TEJVGtDzxWtGFZd8rds9d+CCXlU5Js1rYgfLNvxy9iJrpHjGrRjoi/3BT9fRyiA==,
-      }
-    engines: { node: '>= 16.0.0' }
+    resolution: {integrity: sha512-AUP1EYJuHraQGsVoCQVIcM7TEJVGtDzxWtGFZd8rds9d+CCXlU5Js1rYgfLNvxy9iJrpHjGrRjoi/3BT9fRyiA==}
+    engines: {node: '>= 16.0.0'}
     peerDependencies:
       pg-native: '>=3.0.1'
     peerDependenciesMeta:
@@ -13249,148 +9409,85 @@ packages:
         optional: true
 
   pgpass@1.0.5:
-    resolution:
-      {
-        integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==,
-      }
+    resolution: {integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==}
 
   pgsql-deparser@17.18.3:
-    resolution:
-      {
-        integrity: sha512-lD8kPWgw9KAbUbKbQKgzDGzVdtEmp25N+7qZl62I7v8Uu9Wqy7+M0EOeU96++OgPD9S1pyp9MKNGzZzPJF2C4Q==,
-      }
+    resolution: {integrity: sha512-lD8kPWgw9KAbUbKbQKgzDGzVdtEmp25N+7qZl62I7v8Uu9Wqy7+M0EOeU96++OgPD9S1pyp9MKNGzZzPJF2C4Q==}
 
   pgsql-parser@17.9.15:
-    resolution:
-      {
-        integrity: sha512-6+k0EtTn0CEQTR5v2APARu9En4vm46TpmpdMSfKDHkZwWZuEc08B7SeVg32VxNQ2HD5xk+dQ9TD0k9m+S+vFgg==,
-      }
+    resolution: {integrity: sha512-6+k0EtTn0CEQTR5v2APARu9En4vm46TpmpdMSfKDHkZwWZuEc08B7SeVg32VxNQ2HD5xk+dQ9TD0k9m+S+vFgg==}
 
   picocolors@1.1.1:
-    resolution:
-      {
-        integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==,
-      }
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
 
   picomatch-browser@2.2.6:
-    resolution:
-      {
-        integrity: sha512-0ypsOQt9D4e3hziV8O4elD9uN0z/jtUEfxVRtNaAAtXIyUx9m/SzlO020i8YNL2aL/E6blOvvHQcin6HZlFy/w==,
-      }
-    engines: { node: '>=8.6' }
+    resolution: {integrity: sha512-0ypsOQt9D4e3hziV8O4elD9uN0z/jtUEfxVRtNaAAtXIyUx9m/SzlO020i8YNL2aL/E6blOvvHQcin6HZlFy/w==}
+    engines: {node: '>=8.6'}
 
   picomatch@2.3.1:
-    resolution:
-      {
-        integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==,
-      }
-    engines: { node: '>=8.6' }
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
 
   picomatch@4.0.3:
-    resolution:
-      {
-        integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
 
   picomatch@4.0.4:
-    resolution:
-      {
-        integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
+    engines: {node: '>=12'}
 
   pify@2.3.0:
-    resolution:
-      {
-        integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
+    engines: {node: '>=0.10.0'}
 
   pify@3.0.0:
-    resolution:
-      {
-        integrity: sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==}
+    engines: {node: '>=4'}
 
   pify@4.0.1:
-    resolution:
-      {
-        integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
+    engines: {node: '>=6'}
 
   pify@5.0.0:
-    resolution:
-      {
-        integrity: sha512-eW/gHNMlxdSP6dmG6uJip6FXN0EQBwm2clYYd8Wul42Cwu/DK8HEftzsapcNdYe2MfLiIwZqsDk2RDEsTE79hA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-eW/gHNMlxdSP6dmG6uJip6FXN0EQBwm2clYYd8Wul42Cwu/DK8HEftzsapcNdYe2MfLiIwZqsDk2RDEsTE79hA==}
+    engines: {node: '>=10'}
 
   pirates@4.0.7:
-    resolution:
-      {
-        integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==}
+    engines: {node: '>= 6'}
 
   pkg-dir@4.2.0:
-    resolution:
-      {
-        integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==}
+    engines: {node: '>=8'}
 
   playwright-core@1.60.0:
-    resolution:
-      {
-        integrity: sha512-9bW6zvX/m0lEbgTKJ6YppOKx8H3VOPBMOCFh2irXFOT4BbHgrx5hPjwJYLT40Lu+4qtD36qKc/Hn56StUW57IA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-9bW6zvX/m0lEbgTKJ6YppOKx8H3VOPBMOCFh2irXFOT4BbHgrx5hPjwJYLT40Lu+4qtD36qKc/Hn56StUW57IA==}
+    engines: {node: '>=18'}
     hasBin: true
 
   playwright@1.60.0:
-    resolution:
-      {
-        integrity: sha512-hheHdokM8cdqCb0lcE3s+zT4t4W+vvjpGxsZlDnikarzx8tSzMebh3UiFtgqwFwnTnjYQcsyMF8ei2mCO/tpeA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-hheHdokM8cdqCb0lcE3s+zT4t4W+vvjpGxsZlDnikarzx8tSzMebh3UiFtgqwFwnTnjYQcsyMF8ei2mCO/tpeA==}
+    engines: {node: '>=18'}
     hasBin: true
 
   pluralize@7.0.0:
-    resolution:
-      {
-        integrity: sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==}
+    engines: {node: '>=4'}
 
   postcss-selector-parser@6.1.2:
-    resolution:
-      {
-        integrity: sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==}
+    engines: {node: '>=4'}
 
   postcss-value-parser@4.2.0:
-    resolution:
-      {
-        integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==,
-      }
+    resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
 
   postcss@8.5.6:
-    resolution:
-      {
-        integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==,
-      }
-    engines: { node: ^10 || ^12 || >=14 }
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
 
   postgraphile@5.0.3:
-    resolution:
-      {
-        integrity: sha512-gO8xOusrIykV65V1rmkqnUz3ZjDU+1y09uWruUshP+t811JFsEZsE7d3UJNjAxgrBcndU0CzgmEWCbvbD3kehA==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-gO8xOusrIykV65V1rmkqnUz3ZjDU+1y09uWruUshP+t811JFsEZsE7d3UJNjAxgrBcndU0CzgmEWCbvbD3kehA==}
+    engines: {node: '>=22'}
     hasBin: true
     peerDependencies:
       '@dataplan/json': 1.0.0
@@ -13410,133 +9507,76 @@ packages:
         optional: true
 
   postgres-array@2.0.0:
-    resolution:
-      {
-        integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==}
+    engines: {node: '>=4'}
 
   postgres-array@3.0.4:
-    resolution:
-      {
-        integrity: sha512-nAUSGfSDGOaOAEGwqsRY27GPOea7CNipJPOA7lPbdEpx5Kg3qzdP0AaWC5MlhTWV9s4hFX39nomVZ+C4tnGOJQ==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-nAUSGfSDGOaOAEGwqsRY27GPOea7CNipJPOA7lPbdEpx5Kg3qzdP0AaWC5MlhTWV9s4hFX39nomVZ+C4tnGOJQ==}
+    engines: {node: '>=12'}
 
   postgres-bytea@1.0.1:
-    resolution:
-      {
-        integrity: sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==}
+    engines: {node: '>=0.10.0'}
 
   postgres-date@1.0.7:
-    resolution:
-      {
-        integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==}
+    engines: {node: '>=0.10.0'}
 
   postgres-interval@1.2.0:
-    resolution:
-      {
-        integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==}
+    engines: {node: '>=0.10.0'}
 
   postgres-range@1.1.4:
-    resolution:
-      {
-        integrity: sha512-i/hbxIE9803Alj/6ytL7UHQxRvZkI9O4Sy+J3HGc4F4oo/2eQAjTSNJ0bfxyse3bH0nuVesCk+3IRLaMtG3H6w==,
-      }
+    resolution: {integrity: sha512-i/hbxIE9803Alj/6ytL7UHQxRvZkI9O4Sy+J3HGc4F4oo/2eQAjTSNJ0bfxyse3bH0nuVesCk+3IRLaMtG3H6w==}
 
   prelude-ls@1.2.1:
-    resolution:
-      {
-        integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==,
-      }
-    engines: { node: '>= 0.8.0' }
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
 
   prettier@3.8.1:
-    resolution:
-      {
-        integrity: sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==}
+    engines: {node: '>=14'}
     hasBin: true
 
   pretty-format@26.6.2:
-    resolution:
-      {
-        integrity: sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg==,
-      }
-    engines: { node: '>= 10' }
+    resolution: {integrity: sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg==}
+    engines: {node: '>= 10'}
 
   pretty-format@27.5.1:
-    resolution:
-      {
-        integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==,
-      }
-    engines: { node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0 }
+    resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==}
+    engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0}
 
   pretty-format@29.7.0:
-    resolution:
-      {
-        integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==,
-      }
-    engines: { node: ^14.15.0 || ^16.10.0 || >=18.0.0 }
+    resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==}
+    engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
   pretty-format@30.2.0:
-    resolution:
-      {
-        integrity: sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   pretty-format@30.4.1:
-    resolution:
-      {
-        integrity: sha512-K6KiKMHTL4jjX4u3Kir2EW07nRfcqVTXIImx50wbjHQTcZPgg+gjVeNTIT3l3L1Rd4UefxfogquC9J37SoFyyw==,
-      }
-    engines: { node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0 }
+    resolution: {integrity: sha512-K6KiKMHTL4jjX4u3Kir2EW07nRfcqVTXIImx50wbjHQTcZPgg+gjVeNTIT3l3L1Rd4UefxfogquC9J37SoFyyw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
 
   proc-log@4.2.0:
-    resolution:
-      {
-        integrity: sha512-g8+OnU/L2v+wyiVK+D5fA34J7EH8jZ8DDlvwhRCMxmMj7UCBvxiO1mGeN+36JXIKF4zevU4kRBd8lVgG9vLelA==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-g8+OnU/L2v+wyiVK+D5fA34J7EH8jZ8DDlvwhRCMxmMj7UCBvxiO1mGeN+36JXIKF4zevU4kRBd8lVgG9vLelA==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   process-nextick-args@2.0.1:
-    resolution:
-      {
-        integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==,
-      }
+    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
 
   proggy@2.0.0:
-    resolution:
-      {
-        integrity: sha512-69agxLtnI8xBs9gUGqEnK26UfiexpHy+KUpBQWabiytQjnn5wFY8rklAi7GRfABIuPNnQ/ik48+LGLkYYJcy4A==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-69agxLtnI8xBs9gUGqEnK26UfiexpHy+KUpBQWabiytQjnn5wFY8rklAi7GRfABIuPNnQ/ik48+LGLkYYJcy4A==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   promise-all-reject-late@1.0.1:
-    resolution:
-      {
-        integrity: sha512-vuf0Lf0lOxyQREH7GDIOUMLS7kz+gs8i6B+Yi8dC68a2sychGrHTJYghMBD6k7eUcH0H5P73EckCA48xijWqXw==,
-      }
+    resolution: {integrity: sha512-vuf0Lf0lOxyQREH7GDIOUMLS7kz+gs8i6B+Yi8dC68a2sychGrHTJYghMBD6k7eUcH0H5P73EckCA48xijWqXw==}
 
   promise-call-limit@3.0.2:
-    resolution:
-      {
-        integrity: sha512-mRPQO2T1QQVw11E7+UdCJu7S61eJVWknzml9sC1heAdj1jxl0fWMBypIt9ZOcLFf8FkG995ZD7RnVk7HH72fZw==,
-      }
+    resolution: {integrity: sha512-mRPQO2T1QQVw11E7+UdCJu7S61eJVWknzml9sC1heAdj1jxl0fWMBypIt9ZOcLFf8FkG995ZD7RnVk7HH72fZw==}
 
   promise-inflight@1.0.1:
-    resolution:
-      {
-        integrity: sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==,
-      }
+    resolution: {integrity: sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==}
     peerDependencies:
       bluebird: '*'
     peerDependenciesMeta:
@@ -13544,164 +9584,92 @@ packages:
         optional: true
 
   promise-retry@2.0.1:
-    resolution:
-      {
-        integrity: sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==}
+    engines: {node: '>=10'}
 
   promzard@1.0.2:
-    resolution:
-      {
-        integrity: sha512-2FPputGL+mP3jJ3UZg/Dl9YOkovB7DX0oOr+ck5QbZ5MtORtds8k/BZdn+02peDLI8/YWbmzx34k5fA+fHvCVQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-2FPputGL+mP3jJ3UZg/Dl9YOkovB7DX0oOr+ck5QbZ5MtORtds8k/BZdn+02peDLI8/YWbmzx34k5fA+fHvCVQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   proto-list@1.2.4:
-    resolution:
-      {
-        integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==,
-      }
+    resolution: {integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==}
 
   protocols@2.0.2:
-    resolution:
-      {
-        integrity: sha512-hHVTzba3wboROl0/aWRRG9dMytgH6ow//STBZh43l/wQgmMhYhOFi0EHWAPtoCz9IAUymsyP0TSBHkhgMEGNnQ==,
-      }
+    resolution: {integrity: sha512-hHVTzba3wboROl0/aWRRG9dMytgH6ow//STBZh43l/wQgmMhYhOFi0EHWAPtoCz9IAUymsyP0TSBHkhgMEGNnQ==}
 
   proxy-addr@2.0.7:
-    resolution:
-      {
-        integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==,
-      }
-    engines: { node: '>= 0.10' }
+    resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
+    engines: {node: '>= 0.10'}
 
   proxy-from-env@1.1.0:
-    resolution:
-      {
-        integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==,
-      }
+    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
 
   pstree.remy@1.1.8:
-    resolution:
-      {
-        integrity: sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==,
-      }
+    resolution: {integrity: sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==}
 
   punycode.js@2.3.1:
-    resolution:
-      {
-        integrity: sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==}
+    engines: {node: '>=6'}
 
   punycode@2.3.1:
-    resolution:
-      {
-        integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
 
   pure-rand@7.0.1:
-    resolution:
-      {
-        integrity: sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==,
-      }
+    resolution: {integrity: sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==}
 
   qs@6.14.0:
-    resolution:
-      {
-        integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==,
-      }
-    engines: { node: '>=0.6' }
+    resolution: {integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==}
+    engines: {node: '>=0.6'}
 
   qs@6.14.1:
-    resolution:
-      {
-        integrity: sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==,
-      }
-    engines: { node: '>=0.6' }
+    resolution: {integrity: sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==}
+    engines: {node: '>=0.6'}
 
   queue-microtask@1.2.3:
-    resolution:
-      {
-        integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==,
-      }
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
   quick-lru@4.0.1:
-    resolution:
-      {
-        integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==}
+    engines: {node: '>=8'}
 
   range-parser@1.2.1:
-    resolution:
-      {
-        integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
+    engines: {node: '>= 0.6'}
 
   raw-body@3.0.2:
-    resolution:
-      {
-        integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==,
-      }
-    engines: { node: '>= 0.10' }
+    resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}
+    engines: {node: '>= 0.10'}
 
   react-compiler-runtime@19.1.0-rc.1:
-    resolution:
-      {
-        integrity: sha512-wCt6g+cRh8g32QT18/9blfQHywGjYu+4FlEc3CW1mx3pPxYzZZl1y+VtqxRgnKKBCFLIGUYxog4j4rs5YS86hw==,
-      }
+    resolution: {integrity: sha512-wCt6g+cRh8g32QT18/9blfQHywGjYu+4FlEc3CW1mx3pPxYzZZl1y+VtqxRgnKKBCFLIGUYxog4j4rs5YS86hw==}
     peerDependencies:
       react: ^17.0.0 || ^18.0.0 || ^19.0.0 || ^0.0.0-experimental
 
   react-dom@19.2.4:
-    resolution:
-      {
-        integrity: sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==,
-      }
+    resolution: {integrity: sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==}
     peerDependencies:
       react: ^19.2.4
 
   react-dom@19.2.5:
-    resolution:
-      {
-        integrity: sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag==,
-      }
+    resolution: {integrity: sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag==}
     peerDependencies:
       react: ^19.2.5
 
   react-is@16.13.1:
-    resolution:
-      {
-        integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==,
-      }
+    resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
 
   react-is@17.0.2:
-    resolution:
-      {
-        integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==,
-      }
+    resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==}
 
   react-is@18.3.1:
-    resolution:
-      {
-        integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==,
-      }
+    resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
 
   react-is@19.2.6:
-    resolution:
-      {
-        integrity: sha512-XjBR15BhXuylgWGuslhDKqlSayuqvqBX91BP8pauG8kd1zY8kotkNWbXksTCNRarse4kuGbe2kIY05ARtwNIvw==,
-      }
+    resolution: {integrity: sha512-XjBR15BhXuylgWGuslhDKqlSayuqvqBX91BP8pauG8kd1zY8kotkNWbXksTCNRarse4kuGbe2kIY05ARtwNIvw==}
 
   react-query@3.39.3:
-    resolution:
-      {
-        integrity: sha512-nLfLz7GiohKTJDuT4us4X3h/8unOh+00MLb2yJoGTPjxKs2bc1iDhkNx2bd5MKklXnOD3NrVZ+J2UXujA5In4g==,
-      }
+    resolution: {integrity: sha512-nLfLz7GiohKTJDuT4us4X3h/8unOh+00MLb2yJoGTPjxKs2bc1iDhkNx2bd5MKklXnOD3NrVZ+J2UXujA5In4g==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0
       react-dom: '*'
@@ -13713,18 +9681,12 @@ packages:
         optional: true
 
   react-refresh@0.17.0:
-    resolution:
-      {
-        integrity: sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==}
+    engines: {node: '>=0.10.0'}
 
   react-remove-scroll-bar@2.3.8:
-    resolution:
-      {
-        integrity: sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==}
+    engines: {node: '>=10'}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
@@ -13733,11 +9695,8 @@ packages:
         optional: true
 
   react-remove-scroll@2.7.2:
-    resolution:
-      {
-        integrity: sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==}
+    engines: {node: '>=10'}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
@@ -13746,11 +9705,8 @@ packages:
         optional: true
 
   react-style-singleton@2.2.3:
-    resolution:
-      {
-        integrity: sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==}
+    engines: {node: '>=10'}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
@@ -13759,260 +9715,149 @@ packages:
         optional: true
 
   react-test-renderer@19.2.6:
-    resolution:
-      {
-        integrity: sha512-GbS6V23YduFTPiWJ5xICbKEjRcqx1Z90js/V5miqhz7qp/d6xSe9Dd6NjSQODFRdzdsqRMPW82E/sFpPRbY5Mw==,
-      }
+    resolution: {integrity: sha512-GbS6V23YduFTPiWJ5xICbKEjRcqx1Z90js/V5miqhz7qp/d6xSe9Dd6NjSQODFRdzdsqRMPW82E/sFpPRbY5Mw==}
     peerDependencies:
       react: ^19.2.6
 
   react@19.2.4:
-    resolution:
-      {
-        integrity: sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==}
+    engines: {node: '>=0.10.0'}
 
   react@19.2.5:
-    resolution:
-      {
-        integrity: sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA==}
+    engines: {node: '>=0.10.0'}
 
   read-cmd-shim@4.0.0:
-    resolution:
-      {
-        integrity: sha512-yILWifhaSEEytfXI76kB9xEEiG1AiozaCJZ83A87ytjRiN+jVibXjedjCRNjoZviinhG+4UkalO3mWTd8u5O0Q==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-yILWifhaSEEytfXI76kB9xEEiG1AiozaCJZ83A87ytjRiN+jVibXjedjCRNjoZviinhG+4UkalO3mWTd8u5O0Q==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   read-package-json-fast@3.0.2:
-    resolution:
-      {
-        integrity: sha512-0J+Msgym3vrLOUB3hzQCuZHII0xkNGCtz/HJH9xZshwv9DbDwkw1KaE3gx/e2J5rpEY5rtOy6cyhKOPrkP7FZw==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-0J+Msgym3vrLOUB3hzQCuZHII0xkNGCtz/HJH9xZshwv9DbDwkw1KaE3gx/e2J5rpEY5rtOy6cyhKOPrkP7FZw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   read-pkg-up@3.0.0:
-    resolution:
-      {
-        integrity: sha512-YFzFrVvpC6frF1sz8psoHDBGF7fLPc+llq/8NB43oagqWkx8ar5zYtsTORtOjw9W2RHLpWP+zTWwBvf1bCmcSw==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-YFzFrVvpC6frF1sz8psoHDBGF7fLPc+llq/8NB43oagqWkx8ar5zYtsTORtOjw9W2RHLpWP+zTWwBvf1bCmcSw==}
+    engines: {node: '>=4'}
 
   read-pkg-up@7.0.1:
-    resolution:
-      {
-        integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==}
+    engines: {node: '>=8'}
 
   read-pkg@3.0.0:
-    resolution:
-      {
-        integrity: sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==}
+    engines: {node: '>=4'}
 
   read-pkg@5.2.0:
-    resolution:
-      {
-        integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==}
+    engines: {node: '>=8'}
 
   read@3.0.1:
-    resolution:
-      {
-        integrity: sha512-SLBrDU/Srs/9EoWhU5GdbAoxG1GzpQHo/6qiGItaoLJ1thmYpcNIM1qISEUvyHBzfGlWIyd6p2DNi1oV1VmAuw==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-SLBrDU/Srs/9EoWhU5GdbAoxG1GzpQHo/6qiGItaoLJ1thmYpcNIM1qISEUvyHBzfGlWIyd6p2DNi1oV1VmAuw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   readable-stream@1.0.34:
-    resolution:
-      {
-        integrity: sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==,
-      }
+    resolution: {integrity: sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==}
 
   readable-stream@2.3.8:
-    resolution:
-      {
-        integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==,
-      }
+    resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
 
   readable-stream@3.6.2:
-    resolution:
-      {
-        integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==,
-      }
-    engines: { node: '>= 6' }
+    resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
+    engines: {node: '>= 6'}
 
   readdirp@3.6.0:
-    resolution:
-      {
-        integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==,
-      }
-    engines: { node: '>=8.10.0' }
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
 
   redent@3.0.0:
-    resolution:
-      {
-        integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==}
+    engines: {node: '>=8'}
 
   regenerator-runtime@0.10.5:
-    resolution:
-      {
-        integrity: sha512-02YopEIhAgiBHWeoTiA8aitHDt8z6w+rQqNuIftlM+ZtvSl/brTouaU7DW6GO/cHtvxJvS4Hwv2ibKdxIRi24w==,
-      }
+    resolution: {integrity: sha512-02YopEIhAgiBHWeoTiA8aitHDt8z6w+rQqNuIftlM+ZtvSl/brTouaU7DW6GO/cHtvxJvS4Hwv2ibKdxIRi24w==}
 
   relateurl@0.2.7:
-    resolution:
-      {
-        integrity: sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==,
-      }
-    engines: { node: '>= 0.10' }
+    resolution: {integrity: sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==}
+    engines: {node: '>= 0.10'}
 
   remove-accents@0.5.0:
-    resolution:
-      {
-        integrity: sha512-8g3/Otx1eJaVD12e31UbJj1YzdtVvzH85HV7t+9MJYk/u3XmkOUJ5Ys9wQrf9PCPK8+xn4ymzqYCiZl6QWKn+A==,
-      }
+    resolution: {integrity: sha512-8g3/Otx1eJaVD12e31UbJj1YzdtVvzH85HV7t+9MJYk/u3XmkOUJ5Ys9wQrf9PCPK8+xn4ymzqYCiZl6QWKn+A==}
 
   request-ip@3.3.0:
-    resolution:
-      {
-        integrity: sha512-cA6Xh6e0fDBBBwH77SLJaJPBmD3nWVAcF9/XAcsrIHdjhFzFiB5aNQFytdjCGPezU3ROwrR11IddKAM08vohxA==,
-      }
+    resolution: {integrity: sha512-cA6Xh6e0fDBBBwH77SLJaJPBmD3nWVAcF9/XAcsrIHdjhFzFiB5aNQFytdjCGPezU3ROwrR11IddKAM08vohxA==}
 
   require-directory@2.1.1:
-    resolution:
-      {
-        integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
+    engines: {node: '>=0.10.0'}
 
   require-from-string@2.0.2:
-    resolution:
-      {
-        integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
+    engines: {node: '>=0.10.0'}
 
   require-main-filename@2.0.0:
-    resolution:
-      {
-        integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==,
-      }
+    resolution: {integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==}
 
   requires-port@1.0.0:
-    resolution:
-      {
-        integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==,
-      }
+    resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==}
 
   resolve-cwd@3.0.0:
-    resolution:
-      {
-        integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==}
+    engines: {node: '>=8'}
 
   resolve-from@4.0.0:
-    resolution:
-      {
-        integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
 
   resolve-from@5.0.0:
-    resolution:
-      {
-        integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
 
   resolve-pkg-maps@1.0.0:
-    resolution:
-      {
-        integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==,
-      }
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
   resolve.exports@2.0.3:
-    resolution:
-      {
-        integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==}
+    engines: {node: '>=10'}
 
   resolve@1.22.11:
-    resolution:
-      {
-        integrity: sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==}
+    engines: {node: '>= 0.4'}
     hasBin: true
 
   restore-cursor@3.1.0:
-    resolution:
-      {
-        integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==}
+    engines: {node: '>=8'}
 
   retry@0.12.0:
-    resolution:
-      {
-        integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==,
-      }
-    engines: { node: '>= 4' }
+    resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==}
+    engines: {node: '>= 4'}
 
   retry@0.13.1:
-    resolution:
-      {
-        integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==,
-      }
-    engines: { node: '>= 4' }
+    resolution: {integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==}
+    engines: {node: '>= 4'}
 
   reusify@1.1.0:
-    resolution:
-      {
-        integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==,
-      }
-    engines: { iojs: '>=1.0.0', node: '>=0.10.0' }
+    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
 
   rimraf@3.0.2:
-    resolution:
-      {
-        integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==,
-      }
+    resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
     deprecated: Rimraf versions prior to v4 are no longer supported
     hasBin: true
 
   rimraf@4.4.1:
-    resolution:
-      {
-        integrity: sha512-Gk8NlF062+T9CqNGn6h4tls3k6T1+/nXdOcSZVikNVtlRdYpA7wRJJMoXmuvOnLW844rPjdQ7JgXCYM6PPC/og==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-Gk8NlF062+T9CqNGn6h4tls3k6T1+/nXdOcSZVikNVtlRdYpA7wRJJMoXmuvOnLW844rPjdQ7JgXCYM6PPC/og==}
+    engines: {node: '>=14'}
     hasBin: true
 
   rimraf@6.1.3:
-    resolution:
-      {
-        integrity: sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA==,
-      }
-    engines: { node: 20 || >=22 }
+    resolution: {integrity: sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA==}
+    engines: {node: 20 || >=22}
     hasBin: true
 
   rollup-plugin-visualizer@6.0.5:
-    resolution:
-      {
-        integrity: sha512-9+HlNgKCVbJDs8tVtjQ43US12eqaiHyyiLMdBwQ7vSZPiHMysGNo2E88TAp1si5wx8NAoYriI2A5kuKfIakmJg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-9+HlNgKCVbJDs8tVtjQ43US12eqaiHyyiLMdBwQ7vSZPiHMysGNo2E88TAp1si5wx8NAoYriI2A5kuKfIakmJg==}
+    engines: {node: '>=18'}
     hasBin: true
     peerDependencies:
       rolldown: 1.x || ^1.0.0-beta
@@ -14024,45 +9869,27 @@ packages:
         optional: true
 
   rollup@4.57.1:
-    resolution:
-      {
-        integrity: sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==,
-      }
-    engines: { node: '>=18.0.0', npm: '>=8.0.0' }
+    resolution: {integrity: sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
     hasBin: true
 
   router@2.2.0:
-    resolution:
-      {
-        integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
+    engines: {node: '>= 18'}
 
   rrweb-cssom@0.8.0:
-    resolution:
-      {
-        integrity: sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==,
-      }
+    resolution: {integrity: sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==}
 
   run-async@2.4.1:
-    resolution:
-      {
-        integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==,
-      }
-    engines: { node: '>=0.12.0' }
+    resolution: {integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==}
+    engines: {node: '>=0.12.0'}
 
   run-parallel@1.2.0:
-    resolution:
-      {
-        integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==,
-      }
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
 
   ruru-types@2.0.0:
-    resolution:
-      {
-        integrity: sha512-7dBZHeU8Pnj0V+tLiPzr8RhpdsNuAwu5yhZqcolu6pzpItLG/LKKzN+gKAiCp17z6Lfpdu7bXs+9JS39PO+VxA==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-7dBZHeU8Pnj0V+tLiPzr8RhpdsNuAwu5yhZqcolu6pzpItLG/LKKzN+gKAiCp17z6Lfpdu7bXs+9JS39PO+VxA==}
+    engines: {node: '>=22'}
     peerDependencies:
       graphql: 16.13.0
       react: ^18 || ^19
@@ -14074,11 +9901,8 @@ packages:
         optional: true
 
   ruru@2.0.0:
-    resolution:
-      {
-        integrity: sha512-I8N4Jw0jsgFqgUnsLMR9BHnWyVX0xj7GfDYIjsvjt538zIVs/PiggdepsYjH6K2ul9bjHoS15p7XL2SnywSdCw==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-I8N4Jw0jsgFqgUnsLMR9BHnWyVX0xj7GfDYIjsvjt538zIVs/PiggdepsYjH6K2ul9bjHoS15p7XL2SnywSdCw==}
+    engines: {node: '>=22'}
     hasBin: true
     peerDependencies:
       graphile-config: ^1.0.0-rc.5
@@ -14092,751 +9916,421 @@ packages:
         optional: true
 
   rxjs@7.8.2:
-    resolution:
-      {
-        integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==,
-      }
+    resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==}
 
   safe-buffer@5.1.2:
-    resolution:
-      {
-        integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==,
-      }
+    resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
 
   safe-buffer@5.2.1:
-    resolution:
-      {
-        integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==,
-      }
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
 
   safer-buffer@2.1.2:
-    resolution:
-      {
-        integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==,
-      }
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
 
   saxes@6.0.0:
-    resolution:
-      {
-        integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==,
-      }
-    engines: { node: '>=v12.22.7' }
+    resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
+    engines: {node: '>=v12.22.7'}
 
   scheduler@0.27.0:
-    resolution:
-      {
-        integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==,
-      }
+    resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
 
   schema-typescript@0.14.3:
-    resolution:
-      {
-        integrity: sha512-DvagD66tMo1rDmvCQKZvBNCadk54vGJF/glzBvS4M57IRCOSpbczWHpq0dwEcLpl+EbsIusK4cUsL+RKXVaeYA==,
-      }
+    resolution: {integrity: sha512-DvagD66tMo1rDmvCQKZvBNCadk54vGJF/glzBvS4M57IRCOSpbczWHpq0dwEcLpl+EbsIusK4cUsL+RKXVaeYA==}
 
   semver@5.7.2:
-    resolution:
-      {
-        integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==,
-      }
+    resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
     hasBin: true
 
   semver@6.3.1:
-    resolution:
-      {
-        integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==,
-      }
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
 
   semver@7.7.3:
-    resolution:
-      {
-        integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
+    engines: {node: '>=10'}
     hasBin: true
 
   semver@7.7.4:
-    resolution:
-      {
-        integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
+    engines: {node: '>=10'}
     hasBin: true
 
   semver@7.8.1:
-    resolution:
-      {
-        integrity: sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==}
+    engines: {node: '>=10'}
     hasBin: true
 
   send@1.2.1:
-    resolution:
-      {
-        integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==}
+    engines: {node: '>= 18'}
 
   serve-static@2.2.1:
-    resolution:
-      {
-        integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==,
-      }
-    engines: { node: '>= 18' }
+    resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==}
+    engines: {node: '>= 18'}
 
   set-blocking@2.0.0:
-    resolution:
-      {
-        integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==,
-      }
+    resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
 
   set-value@4.1.0:
-    resolution:
-      {
-        integrity: sha512-zTEg4HL0RwVrqcWs3ztF+x1vkxfm0lP+MQQFPiMJTKVceBwEV0A569Ou8l9IYQG8jOZdMVI1hGsc0tmeD2o/Lw==,
-      }
-    engines: { node: '>=11.0' }
+    resolution: {integrity: sha512-zTEg4HL0RwVrqcWs3ztF+x1vkxfm0lP+MQQFPiMJTKVceBwEV0A569Ou8l9IYQG8jOZdMVI1hGsc0tmeD2o/Lw==}
+    engines: {node: '>=11.0'}
 
   setprototypeof@1.2.0:
-    resolution:
-      {
-        integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==,
-      }
+    resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
 
   shallow-clone@3.0.1:
-    resolution:
-      {
-        integrity: sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==}
+    engines: {node: '>=8'}
 
   shallowequal@1.1.0:
-    resolution:
-      {
-        integrity: sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==,
-      }
+    resolution: {integrity: sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==}
 
   shebang-command@2.0.0:
-    resolution:
-      {
-        integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
 
   shebang-regex@3.0.0:
-    resolution:
-      {
-        integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
 
   shelljs@0.10.0:
-    resolution:
-      {
-        integrity: sha512-Jex+xw5Mg2qMZL3qnzXIfaxEtBaC4n7xifqaqtrZDdlheR70OGkydrPJWT0V1cA1k3nanC86x9FwAmQl6w3Klw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-Jex+xw5Mg2qMZL3qnzXIfaxEtBaC4n7xifqaqtrZDdlheR70OGkydrPJWT0V1cA1k3nanC86x9FwAmQl6w3Klw==}
+    engines: {node: '>=18'}
 
   side-channel-list@1.0.0:
-    resolution:
-      {
-        integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+    engines: {node: '>= 0.4'}
 
   side-channel-map@1.0.1:
-    resolution:
-      {
-        integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}
+    engines: {node: '>= 0.4'}
 
   side-channel-weakmap@1.0.2:
-    resolution:
-      {
-        integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
+    engines: {node: '>= 0.4'}
 
   side-channel@1.1.0:
-    resolution:
-      {
-        integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+    engines: {node: '>= 0.4'}
 
   signal-exit@3.0.7:
-    resolution:
-      {
-        integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==,
-      }
+    resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
 
   signal-exit@4.1.0:
-    resolution:
-      {
-        integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==,
-      }
-    engines: { node: '>=14' }
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
 
   sigstore@2.3.1:
-    resolution:
-      {
-        integrity: sha512-8G+/XDU8wNsJOQS5ysDVO0Etg9/2uA5gR9l4ZwijjlwxBcrU6RPfwi2+jJmbP+Ap1Hlp/nVAaEO4Fj22/SL2gQ==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-8G+/XDU8wNsJOQS5ysDVO0Etg9/2uA5gR9l4ZwijjlwxBcrU6RPfwi2+jJmbP+Ap1Hlp/nVAaEO4Fj22/SL2gQ==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   simple-update-notifier@2.0.0:
-    resolution:
-      {
-        integrity: sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==}
+    engines: {node: '>=10'}
 
   slash@3.0.0:
-    resolution:
-      {
-        integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
 
   slick@1.12.2:
-    resolution:
-      {
-        integrity: sha512-4qdtOGcBjral6YIBCWJ0ljFSKNLz9KkhbWtuGvUyRowl1kxfuE1x/Z/aJcaiilpb3do9bl5K7/1h9XC5wWpY/A==,
-      }
+    resolution: {integrity: sha512-4qdtOGcBjral6YIBCWJ0ljFSKNLz9KkhbWtuGvUyRowl1kxfuE1x/Z/aJcaiilpb3do9bl5K7/1h9XC5wWpY/A==}
 
   smart-buffer@4.2.0:
-    resolution:
-      {
-        integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==,
-      }
-    engines: { node: '>= 6.0.0', npm: '>= 3.0.0' }
+    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
+    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
 
   smtp-server@3.18.4:
-    resolution:
-      {
-        integrity: sha512-9EnXPG4Tv+2P/TSEUdFTduYn9IxtxNRsOq/ryVj8ZlT+6MU2um9gn2Td2hHlgH1n+saagMWtici3hn5J5PhU+g==,
-      }
-    engines: { node: '>=18.18.0' }
+    resolution: {integrity: sha512-9EnXPG4Tv+2P/TSEUdFTduYn9IxtxNRsOq/ryVj8ZlT+6MU2um9gn2Td2hHlgH1n+saagMWtici3hn5J5PhU+g==}
+    engines: {node: '>=18.18.0'}
 
   socks-proxy-agent@8.0.5:
-    resolution:
-      {
-        integrity: sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==,
-      }
-    engines: { node: '>= 14' }
+    resolution: {integrity: sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==}
+    engines: {node: '>= 14'}
 
   socks@2.8.7:
-    resolution:
-      {
-        integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==,
-      }
-    engines: { node: '>= 10.0.0', npm: '>= 3.0.0' }
+    resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
+    engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
 
   sort-keys@2.0.0:
-    resolution:
-      {
-        integrity: sha512-/dPCrG1s3ePpWm6yBbxZq5Be1dXGLyLn9Z791chDC3NFrpkVbWGzkBwPN1knaciexFXgRJ7hzdnwZ4stHSDmjg==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-/dPCrG1s3ePpWm6yBbxZq5Be1dXGLyLn9Z791chDC3NFrpkVbWGzkBwPN1knaciexFXgRJ7hzdnwZ4stHSDmjg==}
+    engines: {node: '>=4'}
 
   sorted-array-functions@1.3.0:
-    resolution:
-      {
-        integrity: sha512-2sqgzeFlid6N4Z2fUQ1cvFmTOLRi/sEDzSQ0OKYchqgoPmQBVyM3959qYx3fpS6Esef80KjmpgPeEr028dP3OA==,
-      }
+    resolution: {integrity: sha512-2sqgzeFlid6N4Z2fUQ1cvFmTOLRi/sEDzSQ0OKYchqgoPmQBVyM3959qYx3fpS6Esef80KjmpgPeEr028dP3OA==}
 
   source-map-js@1.2.1:
-    resolution:
-      {
-        integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
 
   source-map-resolve@0.6.0:
-    resolution:
-      {
-        integrity: sha512-KXBr9d/fO/bWo97NXsPIAW1bFSBOuCnjbNTBMO7N59hsv5i9yzRDfcYwwt0l04+VqnKC+EwzvJZIP/qkuMgR/w==,
-      }
+    resolution: {integrity: sha512-KXBr9d/fO/bWo97NXsPIAW1bFSBOuCnjbNTBMO7N59hsv5i9yzRDfcYwwt0l04+VqnKC+EwzvJZIP/qkuMgR/w==}
     deprecated: See https://github.com/lydell/source-map-resolve#deprecated
 
   source-map-support@0.5.13:
-    resolution:
-      {
-        integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==,
-      }
+    resolution: {integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==}
 
   source-map@0.6.1:
-    resolution:
-      {
-        integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
 
   source-map@0.7.6:
-    resolution:
-      {
-        integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==,
-      }
-    engines: { node: '>= 12' }
+    resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
+    engines: {node: '>= 12'}
 
   spdx-correct@3.2.0:
-    resolution:
-      {
-        integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==,
-      }
+    resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==}
 
   spdx-exceptions@2.5.0:
-    resolution:
-      {
-        integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==,
-      }
+    resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==}
 
   spdx-expression-parse@3.0.1:
-    resolution:
-      {
-        integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==,
-      }
+    resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==}
 
   spdx-license-ids@3.0.22:
-    resolution:
-      {
-        integrity: sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==,
-      }
+    resolution: {integrity: sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==}
 
   split2@3.2.2:
-    resolution:
-      {
-        integrity: sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==,
-      }
+    resolution: {integrity: sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==}
 
   split2@4.2.0:
-    resolution:
-      {
-        integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==,
-      }
-    engines: { node: '>= 10.x' }
+    resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
+    engines: {node: '>= 10.x'}
 
   split@1.0.1:
-    resolution:
-      {
-        integrity: sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==,
-      }
+    resolution: {integrity: sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==}
 
   sprintf-js@1.0.3:
-    resolution:
-      {
-        integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==,
-      }
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
 
   ssri@10.0.6:
-    resolution:
-      {
-        integrity: sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   stack-utils@2.0.6:
-    resolution:
-      {
-        integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
+    engines: {node: '>=10'}
 
   statuses@1.5.0:
-    resolution:
-      {
-        integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==}
+    engines: {node: '>= 0.6'}
 
   statuses@2.0.2:
-    resolution:
-      {
-        integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
+    engines: {node: '>= 0.8'}
 
   stream-browserify@3.0.0:
-    resolution:
-      {
-        integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==,
-      }
+    resolution: {integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==}
 
   streamsearch@0.1.2:
-    resolution:
-      {
-        integrity: sha512-jos8u++JKm0ARcSUTAZXOVC0mSox7Bhn6sBgty73P1f3JGf7yG2clTbBNHUdde/kdvP2FESam+vM6l8jBrNxHA==,
-      }
-    engines: { node: '>=0.8.0' }
+    resolution: {integrity: sha512-jos8u++JKm0ARcSUTAZXOVC0mSox7Bhn6sBgty73P1f3JGf7yG2clTbBNHUdde/kdvP2FESam+vM6l8jBrNxHA==}
+    engines: {node: '>=0.8.0'}
 
   strfy-js@3.2.2:
-    resolution:
-      {
-        integrity: sha512-hUgJ5k2PR1ivhq4uObxnin5j6GcOr0Y0N1lzi3z6SRhxNqu4rzpDfyoC2ToUAyM8yXNXM0zs6f4KIiqj8NqheQ==,
-      }
+    resolution: {integrity: sha512-hUgJ5k2PR1ivhq4uObxnin5j6GcOr0Y0N1lzi3z6SRhxNqu4rzpDfyoC2ToUAyM8yXNXM0zs6f4KIiqj8NqheQ==}
 
   string-length@4.0.2:
-    resolution:
-      {
-        integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==}
+    engines: {node: '>=10'}
 
   string-width@4.2.3:
-    resolution:
-      {
-        integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
 
   string-width@5.1.2:
-    resolution:
-      {
-        integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
+    engines: {node: '>=12'}
 
   string_decoder@0.10.31:
-    resolution:
-      {
-        integrity: sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==,
-      }
+    resolution: {integrity: sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==}
 
   string_decoder@1.1.1:
-    resolution:
-      {
-        integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==,
-      }
+    resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
 
   string_decoder@1.3.0:
-    resolution:
-      {
-        integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==,
-      }
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
 
   strip-ansi@6.0.1:
-    resolution:
-      {
-        integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
 
   strip-ansi@7.1.2:
-    resolution:
-      {
-        integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==}
+    engines: {node: '>=12'}
 
   strip-bom@3.0.0:
-    resolution:
-      {
-        integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
+    engines: {node: '>=4'}
 
   strip-bom@4.0.0:
-    resolution:
-      {
-        integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==}
+    engines: {node: '>=8'}
 
   strip-final-newline@2.0.0:
-    resolution:
-      {
-        integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
+    engines: {node: '>=6'}
 
   strip-indent@3.0.0:
-    resolution:
-      {
-        integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==}
+    engines: {node: '>=8'}
 
   strip-json-comments@3.1.1:
-    resolution:
-      {
-        integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
 
   strnum@2.3.0:
-    resolution:
-      {
-        integrity: sha512-ums3KNd42PGyx5xaoVTO1mjU1bH3NpY4vsrVlnv9PNGqQj8wd7rJ6nEypLrJ7z5vxK5RP0yMLo6J/Gsm62DI5Q==,
-      }
+    resolution: {integrity: sha512-ums3KNd42PGyx5xaoVTO1mjU1bH3NpY4vsrVlnv9PNGqQj8wd7rJ6nEypLrJ7z5vxK5RP0yMLo6J/Gsm62DI5Q==}
 
   styled-components@5.3.11:
-    resolution:
-      {
-        integrity: sha512-uuzIIfnVkagcVHv9nE0VPlHPSCmXIUGKfJ42LNjxCCTDTL5sgnJ8Z7GZBq0EnLYGln77tPpEpExt2+qa+cZqSw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-uuzIIfnVkagcVHv9nE0VPlHPSCmXIUGKfJ42LNjxCCTDTL5sgnJ8Z7GZBq0EnLYGln77tPpEpExt2+qa+cZqSw==}
+    engines: {node: '>=10'}
     peerDependencies:
       react: '>= 16.8.0'
       react-dom: '>= 16.8.0'
       react-is: '>= 16.8.0'
 
   styled-system@5.1.5:
-    resolution:
-      {
-        integrity: sha512-7VoD0o2R3RKzOzPK0jYrVnS8iJdfkKsQJNiLRDjikOpQVqQHns/DXWaPZOH4tIKkhAT7I6wIsy9FWTWh2X3q+A==,
-      }
+    resolution: {integrity: sha512-7VoD0o2R3RKzOzPK0jYrVnS8iJdfkKsQJNiLRDjikOpQVqQHns/DXWaPZOH4tIKkhAT7I6wIsy9FWTWh2X3q+A==}
 
   superagent@10.3.0:
-    resolution:
-      {
-        integrity: sha512-B+4Ik7ROgVKrQsXTV0Jwp2u+PXYLSlqtDAhYnkkD+zn3yg8s/zjA2MeGayPoY/KICrbitwneDHrjSotxKL+0XQ==,
-      }
-    engines: { node: '>=14.18.0' }
+    resolution: {integrity: sha512-B+4Ik7ROgVKrQsXTV0Jwp2u+PXYLSlqtDAhYnkkD+zn3yg8s/zjA2MeGayPoY/KICrbitwneDHrjSotxKL+0XQ==}
+    engines: {node: '>=14.18.0'}
 
   supertest@7.2.2:
-    resolution:
-      {
-        integrity: sha512-oK8WG9diS3DlhdUkcFn4tkNIiIbBx9lI2ClF8K+b2/m8Eyv47LSawxUzZQSNKUrVb2KsqeTDCcjAAVPYaSLVTA==,
-      }
-    engines: { node: '>=14.18.0' }
+    resolution: {integrity: sha512-oK8WG9diS3DlhdUkcFn4tkNIiIbBx9lI2ClF8K+b2/m8Eyv47LSawxUzZQSNKUrVb2KsqeTDCcjAAVPYaSLVTA==}
+    engines: {node: '>=14.18.0'}
 
   supports-color@5.5.0:
-    resolution:
-      {
-        integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
+    engines: {node: '>=4'}
 
   supports-color@7.2.0:
-    resolution:
-      {
-        integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
 
   supports-color@8.1.1:
-    resolution:
-      {
-        integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
+    engines: {node: '>=10'}
 
   supports-preserve-symlinks-flag@1.0.0:
-    resolution:
-      {
-        integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==,
-      }
-    engines: { node: '>= 0.4' }
+    resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
+    engines: {node: '>= 0.4'}
 
   symbol-tree@3.2.4:
-    resolution:
-      {
-        integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==,
-      }
+    resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
   synckit@0.11.12:
-    resolution:
-      {
-        integrity: sha512-Bh7QjT8/SuKUIfObSXNHNSK6WHo6J1tHCqJsuaFDP7gP0fkzSfTxI8y85JrppZ0h8l0maIgc2tfuZQ6/t3GtnQ==,
-      }
-    engines: { node: ^14.18.0 || >=16.0.0 }
+    resolution: {integrity: sha512-Bh7QjT8/SuKUIfObSXNHNSK6WHo6J1tHCqJsuaFDP7gP0fkzSfTxI8y85JrppZ0h8l0maIgc2tfuZQ6/t3GtnQ==}
+    engines: {node: ^14.18.0 || >=16.0.0}
 
   tabbable@6.4.0:
-    resolution:
-      {
-        integrity: sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==,
-      }
+    resolution: {integrity: sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==}
 
   tamedevil@0.1.1:
-    resolution:
-      {
-        integrity: sha512-YH5/T/FXUYrsfFSsCdLqJwUGAlbTBrK2V78dftXnOIgnOnM9aYBi3C+uUg9pevezjE2ENPyOxHqnXJrTG9WPFQ==,
-      }
-    engines: { node: '>=22' }
+    resolution: {integrity: sha512-YH5/T/FXUYrsfFSsCdLqJwUGAlbTBrK2V78dftXnOIgnOnM9aYBi3C+uUg9pevezjE2ENPyOxHqnXJrTG9WPFQ==}
+    engines: {node: '>=22'}
 
   tar-stream@2.2.0:
-    resolution:
-      {
-        integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
+    engines: {node: '>=6'}
 
   tar@6.2.1:
-    resolution:
-      {
-        integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
+    engines: {node: '>=10'}
     deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
 
   temp-dir@1.0.0:
-    resolution:
-      {
-        integrity: sha512-xZFXEGbG7SNC3itwBzI3RYjq/cEhBkx2hJuKGIUOcEULmkQExXiHat2z/qkISYsuR+IKumhEfKKbV5qXmhICFQ==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-xZFXEGbG7SNC3itwBzI3RYjq/cEhBkx2hJuKGIUOcEULmkQExXiHat2z/qkISYsuR+IKumhEfKKbV5qXmhICFQ==}
+    engines: {node: '>=4'}
 
   test-exclude@6.0.0:
-    resolution:
-      {
-        integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==}
+    engines: {node: '>=8'}
 
   text-extensions@1.9.0:
-    resolution:
-      {
-        integrity: sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==,
-      }
-    engines: { node: '>=0.10' }
+    resolution: {integrity: sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==}
+    engines: {node: '>=0.10'}
 
   through2@2.0.5:
-    resolution:
-      {
-        integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==,
-      }
+    resolution: {integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==}
 
   through@2.3.8:
-    resolution:
-      {
-        integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==,
-      }
+    resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
 
   tinyglobby@0.2.12:
-    resolution:
-      {
-        integrity: sha512-qkf4trmKSIiMTs/E63cxH+ojC2unam7rJ0WrauAzpT3ECNTxGRMlaXxVbfxMUC/w0LaYk6jQ4y/nGR9uBO3tww==,
-      }
-    engines: { node: '>=12.0.0' }
+    resolution: {integrity: sha512-qkf4trmKSIiMTs/E63cxH+ojC2unam7rJ0WrauAzpT3ECNTxGRMlaXxVbfxMUC/w0LaYk6jQ4y/nGR9uBO3tww==}
+    engines: {node: '>=12.0.0'}
 
   tinyglobby@0.2.15:
-    resolution:
-      {
-        integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==,
-      }
-    engines: { node: '>=12.0.0' }
+    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
+    engines: {node: '>=12.0.0'}
 
   tinyglobby@0.2.16:
-    resolution:
-      {
-        integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==,
-      }
-    engines: { node: '>=12.0.0' }
+    resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
+    engines: {node: '>=12.0.0'}
 
   tinypool@2.1.0:
-    resolution:
-      {
-        integrity: sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw==,
-      }
-    engines: { node: ^20.0.0 || >=22.0.0 }
+    resolution: {integrity: sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw==}
+    engines: {node: ^20.0.0 || >=22.0.0}
 
   tldts-core@6.1.86:
-    resolution:
-      {
-        integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==,
-      }
+    resolution: {integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==}
 
   tldts@6.1.86:
-    resolution:
-      {
-        integrity: sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==,
-      }
+    resolution: {integrity: sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==}
     hasBin: true
 
   tmp@0.2.5:
-    resolution:
-      {
-        integrity: sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==,
-      }
-    engines: { node: '>=14.14' }
+    resolution: {integrity: sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==}
+    engines: {node: '>=14.14'}
 
   tmpl@1.0.5:
-    resolution:
-      {
-        integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==,
-      }
+    resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==}
 
   to-regex-range@5.0.1:
-    resolution:
-      {
-        integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==,
-      }
-    engines: { node: '>=8.0' }
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
 
   toidentifier@1.0.1:
-    resolution:
-      {
-        integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==,
-      }
-    engines: { node: '>=0.6' }
+    resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
+    engines: {node: '>=0.6'}
 
   touch@3.1.1:
-    resolution:
-      {
-        integrity: sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==,
-      }
+    resolution: {integrity: sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==}
     hasBin: true
 
   tough-cookie@5.1.2:
-    resolution:
-      {
-        integrity: sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==,
-      }
-    engines: { node: '>=16' }
+    resolution: {integrity: sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==}
+    engines: {node: '>=16'}
 
   tr46@0.0.3:
-    resolution:
-      {
-        integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==,
-      }
+    resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
   tr46@5.1.1:
-    resolution:
-      {
-        integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==}
+    engines: {node: '>=18'}
 
   transliteration@2.6.1:
-    resolution:
-      {
-        integrity: sha512-hJ9BhrQAOnNTbpOr1MxsNjZISkn7ppvF5TKUeFmTE1mG4ZPD/XVxF0L0LUoIUCWmQyxH0gJpVtfYLAWf298U9w==,
-      }
-    engines: { node: '>=20.0.0' }
+    resolution: {integrity: sha512-hJ9BhrQAOnNTbpOr1MxsNjZISkn7ppvF5TKUeFmTE1mG4ZPD/XVxF0L0LUoIUCWmQyxH0gJpVtfYLAWf298U9w==}
+    engines: {node: '>=20.0.0'}
     hasBin: true
 
   treeverse@3.0.0:
-    resolution:
-      {
-        integrity: sha512-gcANaAnd2QDZFmHFEOF4k7uc1J/6a6z3DJMd/QwEyxLoKGiptJRwid582r7QIsFlFMIZ3SnxfS52S4hm2DHkuQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-gcANaAnd2QDZFmHFEOF4k7uc1J/6a6z3DJMd/QwEyxLoKGiptJRwid582r7QIsFlFMIZ3SnxfS52S4hm2DHkuQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   trim-newlines@3.0.1:
-    resolution:
-      {
-        integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==}
+    engines: {node: '>=8'}
 
   ts-api-utils@2.5.0:
-    resolution:
-      {
-        integrity: sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==,
-      }
-    engines: { node: '>=18.12' }
+    resolution: {integrity: sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==}
+    engines: {node: '>=18.12'}
     peerDependencies:
       typescript: '>=4.8.4'
 
   ts-jest@29.4.11:
-    resolution:
-      {
-        integrity: sha512-IrFl7l9AuB/qrNw5quqvAv/hmKMb8dhWOH4jQOGo0Oq8tCeo1O86/iTFG1FaRimgUkF13l4PcepO8ATFT6Ns4g==,
-      }
-    engines: { node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0 }
+    resolution: {integrity: sha512-IrFl7l9AuB/qrNw5quqvAv/hmKMb8dhWOH4jQOGo0Oq8tCeo1O86/iTFG1FaRimgUkF13l4PcepO8ATFT6Ns4g==}
+    engines: {node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0}
     hasBin: true
     peerDependencies:
       '@babel/core': '>=7.0.0-beta.0 <8'
@@ -14862,10 +10356,7 @@ packages:
         optional: true
 
   ts-node@10.9.2:
-    resolution:
-      {
-        integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==,
-      }
+    resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==}
     hasBin: true
     peerDependencies:
       '@swc/core': '>=1.2.50'
@@ -14879,257 +10370,146 @@ packages:
         optional: true
 
   tsconfig-paths@4.2.0:
-    resolution:
-      {
-        integrity: sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==}
+    engines: {node: '>=6'}
 
   tslib@2.8.1:
-    resolution:
-      {
-        integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==,
-      }
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
   tsx@4.21.0:
-    resolution:
-      {
-        integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==,
-      }
-    engines: { node: '>=18.0.0' }
+    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
+    engines: {node: '>=18.0.0'}
     hasBin: true
 
   tuf-js@2.2.1:
-    resolution:
-      {
-        integrity: sha512-GwIJau9XaA8nLVbUXsN3IlFi7WmQ48gBUrl3FTkkL/XLu/POhBzfmX9hd33FNMX1qAsfl6ozO1iMmW9NC8YniA==,
-      }
-    engines: { node: ^16.14.0 || >=18.0.0 }
+    resolution: {integrity: sha512-GwIJau9XaA8nLVbUXsN3IlFi7WmQ48gBUrl3FTkkL/XLu/POhBzfmX9hd33FNMX1qAsfl6ozO1iMmW9NC8YniA==}
+    engines: {node: ^16.14.0 || >=18.0.0}
 
   type-check@0.4.0:
-    resolution:
-      {
-        integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==,
-      }
-    engines: { node: '>= 0.8.0' }
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
 
   type-detect@4.0.8:
-    resolution:
-      {
-        integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==}
+    engines: {node: '>=4'}
 
   type-fest@0.18.1:
-    resolution:
-      {
-        integrity: sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==}
+    engines: {node: '>=10'}
 
   type-fest@0.21.3:
-    resolution:
-      {
-        integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
+    engines: {node: '>=10'}
 
   type-fest@0.4.1:
-    resolution:
-      {
-        integrity: sha512-IwzA/LSfD2vC1/YDYMv/zHP4rDF1usCwllsDpbolT3D4fUepIO7f9K70jjmUewU/LmGUKJcwcVtDCpnKk4BPMw==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-IwzA/LSfD2vC1/YDYMv/zHP4rDF1usCwllsDpbolT3D4fUepIO7f9K70jjmUewU/LmGUKJcwcVtDCpnKk4BPMw==}
+    engines: {node: '>=6'}
 
   type-fest@0.6.0:
-    resolution:
-      {
-        integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==}
+    engines: {node: '>=8'}
 
   type-fest@0.8.1:
-    resolution:
-      {
-        integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==}
+    engines: {node: '>=8'}
 
   type-fest@4.41.0:
-    resolution:
-      {
-        integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==,
-      }
-    engines: { node: '>=16' }
+    resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
+    engines: {node: '>=16'}
 
   type-is@2.0.1:
-    resolution:
-      {
-        integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==,
-      }
-    engines: { node: '>= 0.6' }
+    resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
+    engines: {node: '>= 0.6'}
 
   typedarray@0.0.6:
-    resolution:
-      {
-        integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==,
-      }
+    resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==}
 
   typescript@5.9.3:
-    resolution:
-      {
-        integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==,
-      }
-    engines: { node: '>=14.17' }
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
     hasBin: true
 
   uc.micro@2.1.0:
-    resolution:
-      {
-        integrity: sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==,
-      }
+    resolution: {integrity: sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==}
 
   uglify-js@3.19.3:
-    resolution:
-      {
-        integrity: sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==,
-      }
-    engines: { node: '>=0.8.0' }
+    resolution: {integrity: sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==}
+    engines: {node: '>=0.8.0'}
     hasBin: true
 
   uglify-js@3.4.10:
-    resolution:
-      {
-        integrity: sha512-Y2VsbPVs0FIshJztycsO2SfPk7/KAF/T72qzv9u5EpQ4kB2hQoHlhNQTsNyy6ul7lQtqJN/AoWeS23OzEiEFxw==,
-      }
-    engines: { node: '>=0.8.0' }
+    resolution: {integrity: sha512-Y2VsbPVs0FIshJztycsO2SfPk7/KAF/T72qzv9u5EpQ4kB2hQoHlhNQTsNyy6ul7lQtqJN/AoWeS23OzEiEFxw==}
+    engines: {node: '>=0.8.0'}
     hasBin: true
 
   undefsafe@2.0.5:
-    resolution:
-      {
-        integrity: sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==,
-      }
+    resolution: {integrity: sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==}
 
   undici-types@6.21.0:
-    resolution:
-      {
-        integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==,
-      }
+    resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
 
   undici-types@7.24.6:
-    resolution:
-      {
-        integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==,
-      }
+    resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==}
 
   undici@7.25.0:
-    resolution:
-      {
-        integrity: sha512-xXnp4kTyor2Zq+J1FfPI6Eq3ew5h6Vl0F/8d9XU5zZQf1tX9s2Su1/3PiMmUANFULpmksxkClamIZcaUqryHsQ==,
-      }
-    engines: { node: '>=20.18.1' }
+    resolution: {integrity: sha512-xXnp4kTyor2Zq+J1FfPI6Eq3ew5h6Vl0F/8d9XU5zZQf1tX9s2Su1/3PiMmUANFULpmksxkClamIZcaUqryHsQ==}
+    engines: {node: '>=20.18.1'}
 
   undici@8.3.0:
-    resolution:
-      {
-        integrity: sha512-TkUDgb6tl7KOGZ+7e8E3d2FYgUQgF6z5YypqjWmixVQSQERFcVrVg0ySADm2LVLRh5ljAaHTCR5Fmz3Q34rB7Q==,
-      }
-    engines: { node: '>=22.19.0' }
+    resolution: {integrity: sha512-TkUDgb6tl7KOGZ+7e8E3d2FYgUQgF6z5YypqjWmixVQSQERFcVrVg0ySADm2LVLRh5ljAaHTCR5Fmz3Q34rB7Q==}
+    engines: {node: '>=22.19.0'}
 
   unique-filename@3.0.0:
-    resolution:
-      {
-        integrity: sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   unique-slug@4.0.0:
-    resolution:
-      {
-        integrity: sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   universal-user-agent@6.0.1:
-    resolution:
-      {
-        integrity: sha512-yCzhz6FN2wU1NiiQRogkTQszlQSlpWaw8SvVegAc+bDxbzHgh1vX8uIe8OYyMH6DwH+sdTJsgMl36+mSMdRJIQ==,
-      }
+    resolution: {integrity: sha512-yCzhz6FN2wU1NiiQRogkTQszlQSlpWaw8SvVegAc+bDxbzHgh1vX8uIe8OYyMH6DwH+sdTJsgMl36+mSMdRJIQ==}
 
   universalify@2.0.1:
-    resolution:
-      {
-        integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==,
-      }
-    engines: { node: '>= 10.0.0' }
+    resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
+    engines: {node: '>= 10.0.0'}
 
   unload@2.2.0:
-    resolution:
-      {
-        integrity: sha512-B60uB5TNBLtN6/LsgAf3udH9saB5p7gqJwcFfbOEZ8BcBHnGwCf6G/TGiEqkRAxX7zAFIUtzdrXQSdL3Q/wqNA==,
-      }
+    resolution: {integrity: sha512-B60uB5TNBLtN6/LsgAf3udH9saB5p7gqJwcFfbOEZ8BcBHnGwCf6G/TGiEqkRAxX7zAFIUtzdrXQSdL3Q/wqNA==}
 
   unpipe@1.0.0:
-    resolution:
-      {
-        integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
+    engines: {node: '>= 0.8'}
 
   unrs-resolver@1.12.2:
-    resolution:
-      {
-        integrity: sha512-dmlRxBJJayXjqTwC+JtF1HhJmgf3ftQ3YejFcZrf4+KKtJv0qDsK1pjqaaVjG7wJ5NJ6UVP1OqRMQ71Z4C3rxQ==,
-      }
+    resolution: {integrity: sha512-dmlRxBJJayXjqTwC+JtF1HhJmgf3ftQ3YejFcZrf4+KKtJv0qDsK1pjqaaVjG7wJ5NJ6UVP1OqRMQ71Z4C3rxQ==}
 
   untildify@4.0.0:
-    resolution:
-      {
-        integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==}
+    engines: {node: '>=8'}
 
   upath@2.0.1:
-    resolution:
-      {
-        integrity: sha512-1uEe95xksV1O0CYKXo8vQvN1JEbtJp7lb7C5U9HMsIp6IVwntkH/oNUzyVNQSd4S1sYk2FpSSW44FqMc8qee5w==,
-      }
-    engines: { node: '>=4' }
+    resolution: {integrity: sha512-1uEe95xksV1O0CYKXo8vQvN1JEbtJp7lb7C5U9HMsIp6IVwntkH/oNUzyVNQSd4S1sYk2FpSSW44FqMc8qee5w==}
+    engines: {node: '>=4'}
 
   update-browserslist-db@1.2.3:
-    resolution:
-      {
-        integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==,
-      }
+    resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
     hasBin: true
     peerDependencies:
       browserslist: '>= 4.21.0'
 
   upper-case@1.1.3:
-    resolution:
-      {
-        integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==,
-      }
+    resolution: {integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==}
 
   uri-js@4.4.1:
-    resolution:
-      {
-        integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==,
-      }
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
 
   url-join@4.0.1:
-    resolution:
-      {
-        integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==,
-      }
+    resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==}
 
   use-callback-ref@1.3.3:
-    resolution:
-      {
-        integrity: sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==}
+    engines: {node: '>=10'}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
@@ -15138,11 +10518,8 @@ packages:
         optional: true
 
   use-sidecar@1.1.3:
-    resolution:
-      {
-        integrity: sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==}
+    engines: {node: '>=10'}
     peerDependencies:
       '@types/react': '*'
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
@@ -15151,73 +10528,43 @@ packages:
         optional: true
 
   use-sync-external-store@1.6.0:
-    resolution:
-      {
-        integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==,
-      }
+    resolution: {integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==}
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
   util-deprecate@1.0.2:
-    resolution:
-      {
-        integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==,
-      }
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
 
   uuid@10.0.0:
-    resolution:
-      {
-        integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==,
-      }
+    resolution: {integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==}
     deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
   v8-compile-cache-lib@3.0.1:
-    resolution:
-      {
-        integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==,
-      }
+    resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
 
   v8-to-istanbul@9.3.0:
-    resolution:
-      {
-        integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==,
-      }
-    engines: { node: '>=10.12.0' }
+    resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==}
+    engines: {node: '>=10.12.0'}
 
   valid-data-url@3.0.1:
-    resolution:
-      {
-        integrity: sha512-jOWVmzVceKlVVdwjNSenT4PbGghU0SBIizAev8ofZVgivk/TVHXSbNL8LP6M3spZvkR9/QolkyJavGSX5Cs0UA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-jOWVmzVceKlVVdwjNSenT4PbGghU0SBIizAev8ofZVgivk/TVHXSbNL8LP6M3spZvkR9/QolkyJavGSX5Cs0UA==}
+    engines: {node: '>=10'}
 
   validate-npm-package-license@3.0.4:
-    resolution:
-      {
-        integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==,
-      }
+    resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
 
   validate-npm-package-name@5.0.1:
-    resolution:
-      {
-        integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   vary@1.1.2:
-    resolution:
-      {
-        integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==,
-      }
-    engines: { node: '>= 0.8' }
+    resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
+    engines: {node: '>= 0.8'}
 
   vite@6.4.1:
-    resolution:
-      {
-        integrity: sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==,
-      }
-    engines: { node: ^18.0.0 || ^20.0.0 || >=22.0.0 }
+    resolution: {integrity: sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==}
+    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
     hasBin: true
     peerDependencies:
       '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
@@ -15256,191 +10603,107 @@ packages:
         optional: true
 
   vscode-languageserver-types@3.17.5:
-    resolution:
-      {
-        integrity: sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==,
-      }
+    resolution: {integrity: sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==}
 
   w3c-xmlserializer@5.0.0:
-    resolution:
-      {
-        integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==}
+    engines: {node: '>=18'}
 
   walk-up-path@3.0.1:
-    resolution:
-      {
-        integrity: sha512-9YlCL/ynK3CTlrSRrDxZvUauLzAswPCrsaCgilqFevUYpeEW0/3ScEjaa3kbW/T0ghhkEr7mv+fpjqn1Y1YuTA==,
-      }
+    resolution: {integrity: sha512-9YlCL/ynK3CTlrSRrDxZvUauLzAswPCrsaCgilqFevUYpeEW0/3ScEjaa3kbW/T0ghhkEr7mv+fpjqn1Y1YuTA==}
 
   walker@1.0.8:
-    resolution:
-      {
-        integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==,
-      }
+    resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==}
 
   warning@3.0.0:
-    resolution:
-      {
-        integrity: sha512-jMBt6pUrKn5I+OGgtQ4YZLdhIeJmObddh6CsibPxyQ5yPZm1XExSyzC1LCNX7BzhxWgiHmizBWJTHJIjMjTQYQ==,
-      }
+    resolution: {integrity: sha512-jMBt6pUrKn5I+OGgtQ4YZLdhIeJmObddh6CsibPxyQ5yPZm1XExSyzC1LCNX7BzhxWgiHmizBWJTHJIjMjTQYQ==}
 
   wcwidth@1.0.1:
-    resolution:
-      {
-        integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==,
-      }
+    resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==}
 
   web-resource-inliner@5.0.0:
-    resolution:
-      {
-        integrity: sha512-AIihwH+ZmdHfkJm7BjSXiEClVt4zUFqX4YlFAzjL13wLtDuUneSaFvDBTbdYRecs35SiU7iNKbMnN+++wVfb6A==,
-      }
-    engines: { node: '>=10.0.0' }
+    resolution: {integrity: sha512-AIihwH+ZmdHfkJm7BjSXiEClVt4zUFqX4YlFAzjL13wLtDuUneSaFvDBTbdYRecs35SiU7iNKbMnN+++wVfb6A==}
+    engines: {node: '>=10.0.0'}
 
   webidl-conversions@3.0.1:
-    resolution:
-      {
-        integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==,
-      }
+    resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
   webidl-conversions@7.0.0:
-    resolution:
-      {
-        integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
+    engines: {node: '>=12'}
 
   whatwg-encoding@3.1.1:
-    resolution:
-      {
-        integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==}
+    engines: {node: '>=18'}
     deprecated: Use @exodus/bytes instead for a more spec-conformant and faster implementation
 
   whatwg-mimetype@4.0.0:
-    resolution:
-      {
-        integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==}
+    engines: {node: '>=18'}
 
   whatwg-url@14.2.0:
-    resolution:
-      {
-        integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==}
+    engines: {node: '>=18'}
 
   whatwg-url@5.0.0:
-    resolution:
-      {
-        integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==,
-      }
+    resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
 
   which-module@2.0.1:
-    resolution:
-      {
-        integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==,
-      }
+    resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==}
 
   which@2.0.2:
-    resolution:
-      {
-        integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==,
-      }
-    engines: { node: '>= 8' }
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
     hasBin: true
 
   which@4.0.0:
-    resolution:
-      {
-        integrity: sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==,
-      }
-    engines: { node: ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==}
+    engines: {node: ^16.13.0 || >=18.0.0}
     hasBin: true
 
   wide-align@1.1.5:
-    resolution:
-      {
-        integrity: sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==,
-      }
+    resolution: {integrity: sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==}
 
   word-wrap@1.2.5:
-    resolution:
-      {
-        integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==,
-      }
-    engines: { node: '>=0.10.0' }
+    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
+    engines: {node: '>=0.10.0'}
 
   wordwrap@1.0.0:
-    resolution:
-      {
-        integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==,
-      }
+    resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==}
 
   wrap-ansi@6.2.0:
-    resolution:
-      {
-        integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
+    engines: {node: '>=8'}
 
   wrap-ansi@7.0.0:
-    resolution:
-      {
-        integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
+    engines: {node: '>=10'}
 
   wrap-ansi@8.1.0:
-    resolution:
-      {
-        integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
+    engines: {node: '>=12'}
 
   wrappy@1.0.2:
-    resolution:
-      {
-        integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==,
-      }
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
   write-file-atomic@2.4.3:
-    resolution:
-      {
-        integrity: sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==,
-      }
+    resolution: {integrity: sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==}
 
   write-file-atomic@5.0.1:
-    resolution:
-      {
-        integrity: sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==,
-      }
-    engines: { node: ^14.17.0 || ^16.13.0 || >=18.0.0 }
+    resolution: {integrity: sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
   write-json-file@3.2.0:
-    resolution:
-      {
-        integrity: sha512-3xZqT7Byc2uORAatYiP3DHUUAVEkNOswEWNs9H5KXiicRTvzYzYqKjYc4G7p+8pltvAw641lVByKVtMpf+4sYQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-3xZqT7Byc2uORAatYiP3DHUUAVEkNOswEWNs9H5KXiicRTvzYzYqKjYc4G7p+8pltvAw641lVByKVtMpf+4sYQ==}
+    engines: {node: '>=6'}
 
   write-pkg@4.0.0:
-    resolution:
-      {
-        integrity: sha512-v2UQ+50TNf2rNHJ8NyWttfm/EJUBWMJcx6ZTYZr6Qp52uuegWw/lBkCtCbnYZEmPRNL61m+u67dAmGxo+HTULA==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-v2UQ+50TNf2rNHJ8NyWttfm/EJUBWMJcx6ZTYZr6Qp52uuegWw/lBkCtCbnYZEmPRNL61m+u67dAmGxo+HTULA==}
+    engines: {node: '>=8'}
 
   ws@8.20.1:
-    resolution:
-      {
-        integrity: sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==,
-      }
-    engines: { node: '>=10.0.0' }
+    resolution: {integrity: sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==}
+    engines: {node: '>=10.0.0'}
     peerDependencies:
       bufferutil: ^4.0.1
       utf-8-validate: '>=5.0.2'
@@ -15451,133 +10714,76 @@ packages:
         optional: true
 
   xml-name-validator@5.0.0:
-    resolution:
-      {
-        integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==,
-      }
-    engines: { node: '>=18' }
+    resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
+    engines: {node: '>=18'}
 
   xml-naming@0.1.0:
-    resolution:
-      {
-        integrity: sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw==,
-      }
-    engines: { node: '>=16.0.0' }
+    resolution: {integrity: sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw==}
+    engines: {node: '>=16.0.0'}
 
   xmlchars@2.2.0:
-    resolution:
-      {
-        integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==,
-      }
+    resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
 
   xtend@4.0.2:
-    resolution:
-      {
-        integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==,
-      }
-    engines: { node: '>=0.4' }
+    resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
+    engines: {node: '>=0.4'}
 
   y18n@4.0.3:
-    resolution:
-      {
-        integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==,
-      }
+    resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==}
 
   y18n@5.0.8:
-    resolution:
-      {
-        integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
+    engines: {node: '>=10'}
 
   yallist@3.1.1:
-    resolution:
-      {
-        integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==,
-      }
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
 
   yallist@4.0.0:
-    resolution:
-      {
-        integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==,
-      }
+    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
 
   yaml@2.8.4:
-    resolution:
-      {
-        integrity: sha512-ml/JPOj9fOQK8RNnWojA67GbZ0ApXAUlN2UQclwv2eVgTgn7O9gg9o7paZWKMp4g0H3nTLtS9LVzhkpOFIKzog==,
-      }
-    engines: { node: '>= 14.6' }
+    resolution: {integrity: sha512-ml/JPOj9fOQK8RNnWojA67GbZ0ApXAUlN2UQclwv2eVgTgn7O9gg9o7paZWKMp4g0H3nTLtS9LVzhkpOFIKzog==}
+    engines: {node: '>= 14.6'}
     hasBin: true
 
   yanse@0.2.1:
-    resolution:
-      {
-        integrity: sha512-SMi3ZO1IqsvPLLXuy8LBCP1orqcjOT8VygiuyAlplaGeH2g+n4ZSSyWlA/BZjuUuN58TyOcz89mVkflSqIPxxQ==,
-      }
+    resolution: {integrity: sha512-SMi3ZO1IqsvPLLXuy8LBCP1orqcjOT8VygiuyAlplaGeH2g+n4ZSSyWlA/BZjuUuN58TyOcz89mVkflSqIPxxQ==}
 
   yargs-parser@18.1.3:
-    resolution:
-      {
-        integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==}
+    engines: {node: '>=6'}
 
   yargs-parser@20.2.9:
-    resolution:
-      {
-        integrity: sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==}
+    engines: {node: '>=10'}
 
   yargs-parser@21.1.1:
-    resolution:
-      {
-        integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
+    engines: {node: '>=12'}
 
   yargs@15.4.1:
-    resolution:
-      {
-        integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==,
-      }
-    engines: { node: '>=8' }
+    resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==}
+    engines: {node: '>=8'}
 
   yargs@16.2.0:
-    resolution:
-      {
-        integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==}
+    engines: {node: '>=10'}
 
   yargs@17.7.2:
-    resolution:
-      {
-        integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==,
-      }
-    engines: { node: '>=12' }
+    resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
+    engines: {node: '>=12'}
 
   yn@3.1.1:
-    resolution:
-      {
-        integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==,
-      }
-    engines: { node: '>=6' }
+    resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==}
+    engines: {node: '>=6'}
 
   yocto-queue@0.1.0:
-    resolution:
-      {
-        integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==,
-      }
-    engines: { node: '>=10' }
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
 
   zustand@5.0.11:
-    resolution:
-      {
-        integrity: sha512-fdZY+dk7zn/vbWNCYmzZULHRrss0jx5pPFiOuMZ/5HJN6Yv3u+1Wswy/4MpZEkEGhtNH+pwxZB8OKgUBPzYAGg==,
-      }
-    engines: { node: '>=12.20.0' }
+    resolution: {integrity: sha512-fdZY+dk7zn/vbWNCYmzZULHRrss0jx5pPFiOuMZ/5HJN6Yv3u+1Wswy/4MpZEkEGhtNH+pwxZB8OKgUBPzYAGg==}
+    engines: {node: '>=12.20.0'}
     peerDependencies:
       '@types/react': '>=18.0.0'
       immer: '>=9.0.6'
@@ -15594,6 +10800,7 @@ packages:
         optional: true
 
 snapshots:
+
   '@0no-co/graphql.web@1.2.0(graphql@16.13.0)':
     optionalDependencies:
       graphql: 16.13.0
@@ -16854,6 +12061,13 @@ snapshots:
     optionalDependencies:
       jest: 30.4.2(@types/node@22.19.11)(ts-node@10.9.2(@types/node@22.19.11)(typescript@5.9.3))
 
+  '@inquirerer/test@1.4.3(jest@30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3)))':
+    dependencies:
+      clean-ansi: 0.2.1
+      inquirerer: 4.9.1
+    optionalDependencies:
+      jest: 30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3))
+
   '@inquirerer/utils@3.3.9':
     dependencies:
       appstash: 0.7.0
@@ -16928,6 +12142,43 @@ snapshots:
       - supports-color
       - ts-node
 
+  '@jest/core@30.4.2(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3))':
+    dependencies:
+      '@jest/console': 30.4.1
+      '@jest/pattern': 30.4.0
+      '@jest/reporters': 30.4.1
+      '@jest/test-result': 30.4.1
+      '@jest/transform': 30.4.1
+      '@jest/types': 30.4.1
+      '@types/node': 22.19.19
+      ansi-escapes: 4.3.2
+      chalk: 4.1.2
+      ci-info: 4.4.0
+      exit-x: 0.2.2
+      fast-json-stable-stringify: 2.1.0
+      graceful-fs: 4.2.11
+      jest-changed-files: 30.4.1
+      jest-config: 30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3))
+      jest-haste-map: 30.4.1
+      jest-message-util: 30.4.1
+      jest-regex-util: 30.4.0
+      jest-resolve: 30.4.1
+      jest-resolve-dependencies: 30.4.2
+      jest-runner: 30.4.2
+      jest-runtime: 30.4.2
+      jest-snapshot: 30.4.1
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
+      jest-watcher: 30.4.1
+      pretty-format: 30.4.1
+      slash: 3.0.0
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    optional: true
+
   '@jest/diff-sequences@30.0.1': {}
 
   '@jest/diff-sequences@30.4.0': {}
@@ -21073,6 +16324,26 @@ snapshots:
       - supports-color
       - ts-node
 
+  jest-cli@30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3)):
+    dependencies:
+      '@jest/core': 30.4.2(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3))
+      '@jest/test-result': 30.4.1
+      '@jest/types': 30.4.1
+      chalk: 4.1.2
+      exit-x: 0.2.2
+      import-local: 3.2.0
+      jest-config: 30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3))
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - '@types/node'
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    optional: true
+
   jest-config@30.4.2(@types/node@22.19.11)(ts-node@10.9.2(@types/node@22.19.11)(typescript@5.9.3)):
     dependencies:
       '@babel/core': 7.29.0
@@ -21137,6 +16408,39 @@ snapshots:
       - babel-plugin-macros
       - supports-color
 
+  jest-config@30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3)):
+    dependencies:
+      '@babel/core': 7.29.0
+      '@jest/get-type': 30.1.0
+      '@jest/pattern': 30.4.0
+      '@jest/test-sequencer': 30.4.1
+      '@jest/types': 30.4.1
+      babel-jest: 30.4.1(@babel/core@7.29.0)
+      chalk: 4.1.2
+      ci-info: 4.4.0
+      deepmerge: 4.3.1
+      glob: 10.5.0
+      graceful-fs: 4.2.11
+      jest-circus: 30.4.2
+      jest-docblock: 30.4.0
+      jest-environment-node: 30.4.1
+      jest-regex-util: 30.4.0
+      jest-resolve: 30.4.1
+      jest-runner: 30.4.2
+      jest-util: 30.4.1
+      jest-validate: 30.4.1
+      parse-json: 5.2.0
+      pretty-format: 30.4.1
+      slash: 3.0.0
+      strip-json-comments: 3.1.1
+    optionalDependencies:
+      '@types/node': 22.19.19
+      ts-node: 10.9.2(@types/node@22.19.19)(typescript@5.9.3)
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - supports-color
+    optional: true
+
   jest-diff@29.7.0:
     dependencies:
       chalk: 4.1.2
@@ -21430,6 +16734,20 @@ snapshots:
       - supports-color
       - ts-node
 
+  jest@30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3)):
+    dependencies:
+      '@jest/core': 30.4.2(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3))
+      '@jest/types': 30.4.1
+      import-local: 3.2.0
+      jest-cli: 30.4.2(@types/node@22.19.19)(ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3))
+    transitivePeerDependencies:
+      - '@types/node'
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    optional: true
+
   jiti@2.7.0: {}
 
   js-beautify@1.15.4:
@@ -24066,6 +19384,24 @@ snapshots:
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
 
+  ts-node@10.9.2(@types/node@22.19.19)(typescript@5.9.3):
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.12
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 22.19.19
+      acorn: 8.15.0
+      acorn-walk: 8.3.4
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.2
+      make-error: 1.3.6
+      typescript: 5.9.3
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+
   ts-node@10.9.2(@types/node@25.9.1)(typescript@5.9.3):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
diff --git a/scripts/scale-validate/SIZING.md b/scripts/scale-validate/SIZING.md
new file mode 100644
index 0000000000..e42efa2baf
--- /dev/null
+++ b/scripts/scale-validate/SIZING.md
@@ -0,0 +1,205 @@
+# Multi-Tenant Sizing Model — cnc PostGraphile server with blueprint pooling
+
+All constants measured on `feat/scale-phase0` (blueprint pooling + hardening), isolated
+PG 17 rig, 47-tenant fleet, catalog 61k `pg_class` rows. Method and raw data:
+`V2-RESULTS.md` + `out/v2-*-results.jsonl`.
+
+## 2026-07-06 — the introspection filter rewrites the constants
+
+With `GRAPHILE_INTROSPECTION_FILTER=1` (namespace-scoped catalog introspection at the
+pool seam; SDL byte-identical, MD5-proven), the catalog-size axis collapses:
+
+| constant | stock | filtered | factor |
+|---|---|---|---|
+| instance retained heap @61k rows | 1305.6MB (21.9KB/row) | **14.7MB (0.24KB/row)** | 87× |
+| cold schema build | 7165ms | **417ms** | 17× |
+| PG-side introspection spike | +1283MiB | **+17MiB** | 75× |
+| realtime tenant (dedicated instance) | 2596MB | **14.7MB** | 176× |
+
+Capacity with the shipped defaults (B=256MB, T=768MB, planning I=40MiB — measured
+15–35MB): `R(H) = clamp(min(⌊(H−B)/I⌋, ⌊(H−B−T)/I⌋+1), 1, 50)` →
+**1024MB→1 · 1536MB→13 · 2048MB→26 · 3072MB+→50 (cap)**. Measured at 2048MB: six
+resident blueprints use 167MB total; the 187rps knee runs at 339MB. T=768 is a
+stock-era transient reserve — with the filter the true transient is ~50–100MB, so
+`GRAPHILE_CACHE_BUILD_RESERVE_BYTES` can unlock 1024MB→13 / 1536MB→26 / 2048MB→39
+when density at small heaps matters. **Floor: 1024MB minimum heap** (≤768MB heaps die
+under 100%-miss rebuild churn before any governor signal can fire — not a supported
+configuration). RSS ≈ heap×~2.2 at these working sets. Set
+`GRAPHILE_CACHE_INSTANCE_HEAP_BYTES=41943040` so admission plans with the filtered
+instance size.
+
+Churn robustness (fix `46636d4b4`): the build-wait race timer no longer pins built
+instances (was: every evicted ~15MB instance stayed reachable for 180s → forced
+`max=1` churn OOM-killed a 2GB heap in 65s). Post-fix, worst-case all-miss churn at
+2048MB runs a bounded sawtooth at 23 builds/s and recovers cleanly; the realistic
+over-capacity mode (blueprints = capacity+1 rotating) sustains 100% success. The
+heap-pressure governor now measures against V8's actually-exhaustible headroom
+(`used/(used+total_available_size)`) — the old `heap_size_limit` denominator made the
+0.85/0.92 watermarks unreachable at every heap size — and re-checks inside the build
+critical section with `GRAPHILE_BUILD_PRESSURE_SPACING_MS` (default 250ms) spacing
+under elevated pressure.
+
+## The model in one paragraph
+
+Memory cost is driven by **catalog size** (total relations in the PG database), not by
+tenant count. Every *resident schema instance* on the node retains
+`I ≈ 50MB + 21KB × pg_class_rows`, and every *schema build* spikes a PG backend by
+`≈ 37KB × pg_class_rows`. Tenants sharing a blueprint are free (zero marginal heap,
+zero marginal builds). So you size in two axes: **how many relations live in one PG
+database** (shard size) and **how many distinct blueprint shapes a node must keep
+resident** (node capacity R).
+
+## Corrected scaling axes (2026-07-03)
+
+Re-measurement on the isolated 48-logical-tenant rig (catalog **61,341 `pg_class` rows**,
+all tenants as hash-prefixed schema sets inside one physical DB) sharpens the two axes
+above — the laws are unchanged; the *interpretation of R* is refined.
+
+**Per-tenant catalog cost is a near-constant set by the base stack, not the blueprint.**
+Each logical tenant adds a uniform **~901–904 `pg_class` rows**, of which only **~18 come
+from the app blueprint** — the rest is the ~40-module base stack (auth, billing, events,
+limits, `pg_partman` partitions, …) that every tenant carries. Blueprints in
+`constructive-db` are 1–5 tables, so **blueprint size variance is immaterial** to sizing:
+price shards on tenant *count*, treating per-tenant catalog cost as fixed.
+
+**Node memory scales with actively-hot API surfaces × settings variants (R), priced
+class-independently at `I = 22KB × shard catalog rows`** (≈1.45GB at 61k rows; the same
+measurement as the banked 21KB/row V2 constant, rounded). What multiplies I is **R = the
+number of distinct pool keys concurrently hot on the node**. The blueprint cache key is
+`[logicalSchemas, relname-shape-fingerprint, databaseSettings-flags, apiName, mode,
+dbname]`, so **each API surface and each settings variant splits the pool
+independently**. A tenant exposes **~9 APIs / 8 routable hosts** on the rig (admin,
+agent, api, auth, compute, config, objects, usage are routable; notifications is not),
+but **only concurrently-hit surfaces count toward R** — api+auth resident is R=2; add
+admin+usage under live traffic and it is R=4. (`regression run --suite deep`'s
+`multi-api-residency` check measures exactly this.)
+
+**Settings flags are part of the pool key.** The rig currently has **zero
+`services_public.database_settings` / `api_settings` rows** — every tenant runs on column
+defaults (postgis / search / uploads / m2m / connection_filter / ltree **ON**; aggregates
+/ llm / realtime / bulk / i18n **OFF**), so the fleet is uniform and settings split no
+pool *today*. The moment a tenant gets a non-default `database_settings` row its shape
+forks a **second** pooled instance (**+1 to R**) for the same relations.
+
+**`enable_realtime` makes a tenant unpoolable.** Per
+`graphql/server/src/middleware/pooling-decision.ts`, a service with `enableRealtime=true`
+gets a **dedicated per-tenant instance** and can never share — so every realtime tenant
+costs a full I of resident heap on its own. **House realtime tenants in small-catalog
+shards** so that dedicated instance is cheap.
+
+**partman partitions grow the catalog over time.** The base stack partman-partitions
+events / billing / limits / user_auth (~144 partition children per tenant, `premake=2`;
+`part_config` has 349 rows fleet-wide). Partitions are pre-created on each
+`partition_interval`, so catalog rows — and therefore I — **creep upward per tenant per
+interval** until retention drops old partitions. Retention bounds it; an
+unbounded-retention tenant grows I without limit.
+
+**Corrected sizing law (residency floor):**
+
+```
+heap ≥ 256MB  +  R × I  +  768MB
+       └ B ┘      └ resident ┘   └ T ┘
+       base       R instances    one build
+       reserve    @ 22KB/row      transient
+```
+
+i.e. `H ≥ B + R·I + T` — the residency form of the two-constraint budget in
+`computeCapacityFromBudget`. R counts every concurrently-hot **(surface × settings-variant)**
+instance, so a node serving api+auth+admin+usage for one blueprint is R=4, and any
+settings variant on those adds one more.
+
+## Node capacity (implemented in `computeCapacityFromBudget`)
+
+```
+I  = per-instance heap        (measure once per catalog size; 1.30–1.35GB @ 61k rows)
+B  = base reserve             (server + request working set; default 256MB)
+T  = build transient reserve  (one in-flight build;          default 768MB @ 61k rows)
+H  = --max-old-space-size
+
+R = clamp( min( ⌊(H − B) / I⌋,  ⌊(H − B − T) / I⌋ + 1 ), 1, 50 )
+```
+
+Validated points @61k-row catalog (I=1.45GB estimate):
+
+| Heap H | R | Evidence |
+|---|---|---|
+| 896MB / 1152MB | 0 → build aborts | V8 SIGABRT mid-build (floor probes) |
+| 1536MB | 1 | healthy k1, p99 34ms |
+| 2048MB | 1 | healthy single-bp at 188rps; thrash beyond 1 bp |
+| 3584MB | 2 | api+auth both resident, 0 evictions (r2 probe + live soak) |
+| ~5.9GB | 3 (computed) | unvalidated |
+
+**Container sizing:** RSS ≈ heap × 1.4–1.5 (native/external on top of V8 heap).
+A "2GB-heap" node needs a ~3GB container; for a hard-2GB container run heap ≤1400MB —
+which at a 61k-row catalog is BELOW the 1536MB single-instance floor. Practical
+minimum container at this catalog: ~2.5GB (heap 1792).
+
+**Operating rule:** R must cover the node's *actively hit* blueprint set — api AND
+auth shapes count separately. A tenant fleet on one node needs R ≥ 2 (validated: at
+R=1, hourly batch relogins collide with api traffic and failed relogins retry every
+30s → self-sustaining eviction oscillation; at R=2 the same workload runs clean).
+
+## Per-blueprint throughput (one 2GB node, 32 tenants, mixed authenticated workload)
+
+- ≥188 rps sustained, p50 13ms / p99 21ms, zero errors, PG pool at 5 connections —
+  no knee found up to 200 rps (per-request DB time 1–5ms).
+- Warm request latency is independent of tenant count within the blueprint
+  (10 vs 32 tenants: identical).
+- Cold build: ~8s (cold PG relcache) / ~1s rebuild (warm); builds serialize behind
+  `BuildSemaphore(1)`, protecting both node heap and PG.
+
+## PG-database shard sizing (the real tenant limit)
+
+Per-database catalog cost, measured at ~1.19k `pg_class` rows per marketplace tenant:
+
+| Cost | Scaling | Measured |
+|---|---|---|
+| Introspection backend spike | ~37KB/row, PER BUILD | 2.7GB @61k rows; OOM-killed >5.4GB @135k |
+| Backend relcache retention | multi-GB per pooled conn that ever ran a build | accumulates across pool; recycle via `idle_session_timeout` (validated) or pgbouncer `server_lifetime` |
+| Node instance heap | ~21KB/row per resident instance | 1.3GB @61k rows |
+| Provisioning wall time | superlinear | 74s @17k rows → 138s @135k rows |
+
+Shard guidance (marketplace-class tenants, ~1.2k rows each):
+
+| PG node RAM | Safe catalog | ≈ Tenants/shard | Node heap for R=2 |
+|---|---|---|---|
+| 8GB | ~60k rows | ~40–45 | 3.5–4GB |
+| 16GB | ~120k rows | ~85–95 | 5.5–6.5GB (I≈2.6GB) |
+| 32GB | ~250k rows | ~180–200 | 11–13GB (I≈5.4GB) |
+| 64GB | ~500k rows | ~380–400 | 22–26GB (I≈10.7GB) |
+
+(Instance heap I grows with the shard's catalog, so bigger shards need
+disproportionately bigger app nodes — favor MORE, SMALLER shards.)
+
+**1000 tenants, concretely:** 10 shards × ~100 tenants (16GB PG nodes), each shard
+served by one app node with R=2 (heap ~6GB, container ~9GB) — or split api/auth onto
+two 2.5-3GB-heap nodes per shard at R=1 each, accepting the auth/api isolation.
+The blueprint cache key already scopes by database (`d`), so shard-local pooling
+needs no code changes.
+
+## Hardening shipped with this branch (all validated live)
+
+| Mechanism | What it prevents | Knob |
+|---|---|---|
+| Heap-aware cap, floor 1 (`24d49252f`) | over-admission SIGABRT | `GRAPHILE_CACHE_MAX`, `GRAPHILE_CACHE_INSTANCE_HEAP_BYTES` |
+| Two-constraint budget (`0a8a95402`) | wasted capacity / unsafe admits | `GRAPHILE_CACHE_BASE_RESERVE_BYTES`, `GRAPHILE_CACHE_BUILD_RESERVE_BYTES` |
+| Evict-before-build headroom | build spike on a full cache | (automatic) |
+| Memory governor 85%/92% (`0a8a95402`) | pressure death-spiral; refuses builds at critical, keeps serving residents | `GRAPHILE_MEMORY_GOVERNOR[_ELEVATED/_CRITICAL]` |
+| Build wait timeout (`0a8a95402`) | unbounded request queues behind builds | `GRAPHILE_BUILD_TIMEOUT_MS` (503 BUILD_TIMEOUT; build completes in background) |
+| Connection-class error guard (`d42ca1769`) | PG restart killing the whole node | `GRAPHILE_CONNECTION_GUARD=0` to disable |
+| `/metrics` endpoint (`0a8a95402`) | blind operation | `GRAPHILE_METRICS_ENDPOINT=1` |
+| BuildSemaphore(1) | concurrent build spikes (node AND PG) | `GRAPHILE_BUILD_CONCURRENCY` |
+
+PG-side ops: cap the PG container (cgroup OOM → 15–20s crash-recovery, absorbed by
+the guard) and recycle idle backends (`idle_session_timeout` — beware it also reaps
+long-idle clients: LISTEN connections and drivers must reconnect; the server's
+listener does).
+
+## Measuring I for YOUR catalog
+
+```
+node scripts/scale-validate/measure-instance-heap.mjs \
+  --label my-api --host api-<tenant>.<domain> --port 3344 --heap-mb 4096
+```
+Then set `GRAPHILE_CACHE_INSTANCE_HEAP_BYTES` to the measured delta + ~10%.
+Rule of thumb without measuring: `I ≈ 50MB + 21KB × pg_class_rows`.
diff --git a/scripts/scale-validate/V2-RESULTS.md b/scripts/scale-validate/V2-RESULTS.md
new file mode 100644
index 0000000000..78cc2d108a
--- /dev/null
+++ b/scripts/scale-validate/V2-RESULTS.md
@@ -0,0 +1,115 @@
+# V2 — Limits Discovery Results (2GB validation program)
+
+Rig: isolated PG 17 (`constructive-scale-pg`, :5433, container capped 4.5GiB + 1.5GiB swap,
+`idle_session_timeout=120s`), cnc server from `feat/scale-phase0`, blueprint pooling ON,
+fleet = 47 tenants (40 factory clones + reference + 6 divergent seeder tenants),
+catalog = **61,238 pg_class rows / 1,876 namespaces / 48 databases**.
+Workload: token-bucket open-loop harness, authenticated, mix read:0.7 write:0.25 meta:0.05,
+per-tenant bleed sentinel every 60s. All numbers from `out/v2-*-results.jsonl` +
+`out/harness-*.json` + 10s metrics samples (`out/metrics-*.jsonl`).
+
+## Headline findings (chronological discovery order)
+
+1. **PG-side catalog wall.** PostGraphile v5 introspection scans the whole catalog
+   (no schema filter in `pg-introspection@1.0.1`). Backend memory ≈ **37KB per
+   pg_class row** net: ~2.7GiB spike at 61k rows (15s wall); OOM-killed >5.4GiB at
+   135k rows (101 tenants) *even running alone*. JIT/parallel-off does NOT help
+   (inherent: catalog JSON materialization + relcache). Introspection backends
+   RETAIN multi-GB relcache per pooled connection and accumulate across the pool.
+2. **Node-side catalog wall.** EVERY resident instance retains **~1.3GB heap at
+   this catalog** (tenant-api 1304MB ≡ tenant-auth 1307MB ≡ schema-builder 1316MB
+   — class-independent ⇒ it's the introspection graph, ~**21KB per pg_class row**,
+   consistent with the earlier 464MB floor at a ~17k-row catalog). A 700MB-heap
+   build aborts mid-introspection-receive: live memory, not garbage.
+3. **Cap floor over-admission (FIXED, `24d49252f`).** `MIN_CACHE_MAX = 3` overrode
+   the heap-aware budget; count-based headroom never evicted; admitting a second
+   1.3GB build SIGABRT'd the 2GB process (as-shipped div-k1 crash record). Floor
+   is now 1.
+4. **PG restart killed the whole server (FIXED, `d42ca1769`).** PG crash-recovery
+   (its own introspection OOM) terminated every pooled connection; one orphaned pg
+   Client raised an unhandled 'error' event → process exit. A ~15s PG hiccup was a
+   full multi-tenant outage. `installConnectionErrorGuard()` absorbs
+   connection-class errors only (counted in metrics `counters.connGuard`);
+   validated live: **332/349/344 absorbed per thrash step, zero process deaths**.
+
+## Measured constants (61k-row catalog)
+
+| Constant | Value |
+|---|---|
+| Resident instance heap (any class) | ~1.30–1.32GB (~21KB/pg_class row) |
+| Server base heap | ~46–66MB |
+| Build transient | >700MB (1152MB heap aborts with 0 residents) |
+| Min viable heap, 1 resident | **1536MB PASS / 1152MB ABORT** |
+| RSS vs heap | heapMax 1.46GB → RSS 2.2–2.4GB (≈1.5×) |
+| Cold build (cold PG) | ~8s |
+| Rebuild (warm PG relcache) | ~1s; thrash sustains ~1 build/s |
+| Warm request latency (healthy) | p50 21ms / p95 34ms / p99 34ms |
+| Marginal heap per tenant (same blueprint) | **~0** (1460.1/1459.6/1464.1MB @ 10/20/32 tenants) |
+| PG introspection spike | ~37KB/pg_class row; per BUILD; serialized by BuildSemaphore |
+| Provisioning wall time | 74s @17k rows → 138s @135k rows (superlinear in catalog) |
+
+## Regime results @2GB heap (tuned estimate 1.45GB → capacity R=1)
+
+| Step | Result |
+|---|---|
+| div-k1 (1 blueprint ×2 tenants) | HEALTHY: 5584/5584 HTTP 200, p99 34ms, 2 builds, 1 evict |
+| div-k2/k3/k5 (2–5 blueprints, uniform) | THRASH-NOT-CRASH: errRate 1.0, p50 ~1s, p99 6.8s, 429–525 builds/step, heap bounded ≤1.42GB, sentinel passing, 0 process deaths |
+| ten-10/20/33 (1 blueprint, zipf) | HEALTHY at all sizes; zero marginal heap |
+| rps-10/25/50 (full 47-tenant fleet, ~10 blueprints, zipf) | THRASH: zipf tail keeps touching non-resident blueprints; bimodal latency (p50 144ms→89ms resident hits vs 6.8s timeouts) |
+| cold-burst (5 blueprints at once) | 0/5 cold successes at R=1 (mutual eviction + PG churn); warm wave ≤58ms |
+| 3584MB k1/k3/k5 | Same as 2048: R still 1 (budget formula: 3584×0.5/1450 → 1) |
+| Heap floor | 1536 PASS / 1152 ABORT / 896 ABORT |
+| As-shipped control (512MB estimate, floor 3) | div-k1 SIGABRT ~40s in (banked in v2-2048-results.jsonl) |
+
+**Capacity law (current formula):** R = max(1, floor(heap × 0.5 / instanceEstimate)).
+With 1.3GB instances: R=1 for heap ∈ [1.5GB, ~5.8GB]. The safe-but-conservative 0.5
+fraction leaves a 3.5GB node at R=1; a budget of (heap − base − buildTransient)/instance
+would give R(3584)=2 — V4 hardening candidate (validated by the r2 probe below).
+
+**Operating rule:** healthy service requires resident capacity R ≥ number of actively-hit
+blueprints (api and auth blueprints both count; auth is touched at login/relogin only).
+Within one blueprint, tenant count is free (zero marginal heap) up to the PG-side
+catalog walls.
+
+## Architecture consequence (the 1000-tenant answer)
+
+Tenants-per-PG-database is the fundamental unit, bounded by catalog size on BOTH sides
+(PG introspection memory ~37KB/row/backend; node instance heap ~21KB/row/instance;
+provisioning slowdown). Shard tenants across PG databases (the blueprint cache key
+already scopes by dbname `d`); serve each shard with nodes sized R ≥ active blueprint
+shapes. Example: 1000 same-shape tenants = N shards × (1000/N) tenants; each shard
+served by a 2GB node at R=1 (api) — auth co-residency wants R=2 (heap ~4GB with the
+V4 budget formula, or a separate auth node at R=1).
+
+## Rig/ops guidance validated live
+
+- Cap the PG container (cgroup OOM → 15–20s crash-recovery, absorbed by the
+  connection guard) rather than letting the VM OOM-killer roam.
+- `idle_session_timeout` recycles relcache-bloated backends in healthy regimes;
+  under sustained build churn backends never idle — churn regimes need pgbouncer
+  `server_lifetime` or equivalent forced recycling.
+- BuildSemaphore(1) serendipitously serializes PG introspection spikes as well as
+  node build transients — keep it.
+
+## Follow-up probes (both PASS)
+
+- **Capacity-2 at 3584MB** (`r2-div-k1`, estimate lowered to 896MB → cap 2):
+  builds=2, **evictions=0** (api + auth blueprints simultaneously resident),
+  errRate 0, p99 34ms, heapMax **2750MB** (= 2×1.35GB + base, as modeled),
+  rssMax 3.24GB, no crash. True capacity at 3584MB is 2; only the 0.5-fraction
+  budget formula holds it at 1 → V4 hardening: budget = heap − base −
+  buildTransient, divided by instance estimate.
+- **Single-blueprint rps ceiling** (2048MB, 32 tenants, zipf, authenticated
+  mixed workload): 50→100→200 target rps achieved 47/94.3/188.4, errRate 0
+  at every level, p99 34/21/21ms, pgConnMax stayed 5 (PG_POOL_MAX=5/dbname is
+  NOT a bottleneck ≤200rps; queries are 1-5ms). heapMax 1508→1588MB (request
+  working set ≈ +150-250MB over the resident instance at 200rps).
+  **Headline: a 2GB-heap node serves 32 pooled tenants at ≥188rps, p99 21ms,
+  zero errors.**
+
+## Remaining known limitations
+
+- Shape fingerprint covers relation names only (columns excluded — documented
+  limitation; column-drift tenants share a blueprint by design).
+- rps ceiling beyond 200rps unmeasured (no knee found yet).
+- 24h longevity (V3) + memory governor / smarter budget / build timeout (V4).
diff --git a/scripts/scale-validate/VALIDATION-REPORT.md b/scripts/scale-validate/VALIDATION-REPORT.md
new file mode 100644
index 0000000000..9407f803b9
--- /dev/null
+++ b/scripts/scale-validate/VALIDATION-REPORT.md
@@ -0,0 +1,189 @@
+# Scale Validation Program — Final Report (feat/scale-phase0)
+
+**Question under validation:** can the cnc PostGraphile-v5 server host hundreds of
+tenant databases on a small fixed heap, using blueprint pooling (one shared instance
+per schema-shape) — and what actually bounds it?
+
+**Verdict:** pooling works and is production-ready **within a quantified envelope**.
+Tenant count is effectively free *within a blueprint*; the real limits are
+**catalog size per PG database** and **resident blueprint count per node** — both
+now measured, modeled (`SIZING.md`), and enforced by shipped guardrails. The
+original "1000 tenants on one 2GB node" framing resolves to a shard-per-PG-database
+architecture: ~40–200 tenants per shard (PG-node-RAM-dependent), each shard served
+at p99 ≤34ms by a 2–6GB-heap node. Full V2 data: `V2-RESULTS.md`.
+
+## What was validated, in order
+
+**V1 — instrumentation + fleet.** Metrics sampler (10s JSON lines: heap/RSS/cache/
+build/eviction/guard counters), workload harness (open-loop token bucket,
+authenticated read/write/meta mix, zipf/uniform/burst, per-tenant **cross-tenant
+bleed sentinel** that hard-fails on foreign canary rows), SQL tenant factory
+(~0.8 tenants/min, fingerprint-validated identical to seeder output), drift/subset
+tooling, teardown tooling. Fleet: 47 tenants (40 factory + reference + 6 divergent),
+5 deliberate blueprint groups + 2 column-drift probes.
+
+**V2 — limits discovery.** See `V2-RESULTS.md` for the full matrix. Constants:
+instance heap ≈ 50MB + **21KB/pg_class row** (class-independent — it is the
+introspection graph); PG introspection spike ≈ **37KB/row per build**; min viable
+heap 1536MB at the 61k-row catalog; **zero marginal heap per tenant** within a
+blueprint; **188rps p99 21ms zero errors** on one 2GB node (no knee ≤200rps);
+capacity law validated at R=1 (2048MB) and R=2 (3584MB); thrash-not-crash beyond
+capacity; cold-burst needs R ≥ concurrent cold blueprints.
+
+**V3 — 24h soak** (in flight at time of writing; final numbers appended on
+completion). Configuration: hardened build, heap 3584 (capacity 2), 32 same-blueprint
+tenants, 30rps zipf authenticated + hourly NOTIFY churn + 2-hourly tenant
+provision/teardown cycles + RSS/heap collector. Hour-1: 108k requests, 0 errors,
+p99 34ms, **zero LRU evictions through the batch-relogin cliff** that (by design)
+destroyed the capacity-1 control attempt.
+
+**V4 — hardening + model.** `SIZING.md` (capacity law, shard guidance, container
+sizing, knob reference) + the fixes below.
+
+## Findings → fixes (all discovered live by the program)
+
+| # | Finding | Consequence | Fix / disposition |
+|---|---|---|---|
+| 1 | PostGraphile introspection scans the ENTIRE catalog (no schema filter); backend spikes ~37KB/pg_class row and pooled backends RETAIN multi-GB relcache | PG OOM at ~100 tenants/DB even idle; crash-recovery storms | Shard-per-database architecture (SIZING.md); PG container caps; `idle_session_timeout`/pgbouncer `server_lifetime` backend recycling; BuildSemaphore already serializes spikes |
+| 2 | Node instance heap ∝ total catalog (~21KB/row), class-independent, live (not GC-able) | 2GB heap = ONE resident instance at 61k rows; "instance size" is not a constant | Measured model + `GRAPHILE_CACHE_INSTANCE_HEAP_BYTES`; measurement tool shipped |
+| 3 | `MIN_CACHE_MAX=3` floor overrode the heap budget; count-based headroom never evicted | Second build → V8 SIGABRT (whole node dies) — reproduced on demand | **`24d49252f`** floor→1 + regression test |
+| 4 | PG crash-recovery killed the whole server via unhandled 'error' on an orphaned pg Client | 15s PG hiccup = full multi-tenant outage | **`d42ca1769`** scoped connection-class guard (absorbs 57P01/08006/ECONNRESET/…, counts in metrics; everything else stays fatal). Validated: ~330 absorbed/step, 0 process deaths |
+| 5 | Blunt `heap×0.5` budget wasted capacity (3.5GB node stuck at R=1) | Unnecessary thrash for fleets needing api+auth resident | **`0a8a95402`** two-constraint budget (residency + rebuild-with-evict); R=2@3584 proven live |
+| 6 | At R=1, hourly batch relogins + failed-relogin retries create SELF-SUSTAINING api↔auth eviction oscillation | "Capacity ≥ active blueprints" is a hard operating rule, not advice | Soak redesigned to R=2 (clean); rule + math in SIZING.md |
+| 7 | No backpressure: builds admitted at any heap level; requests wait unboundedly | Pressure death-spiral risk; queue pileups | **`0a8a95402`** memory governor (85% proactive evict / 92% refuse builds with 503+Retry-After) + `GRAPHILE_BUILD_TIMEOUT_MS` request wait bound (build continues in background, timed-out requests no longer break coalescing) |
+| 8 | No runtime visibility | blind ops | **`0a8a95402`** `/metrics` endpoint (env-gated, loopback-guarded) + sampler counters incl. governor/guard/refusals |
+| 9 | `pg_partman` registry rows are name-keyed, not FK-cascaded; schema hashes are deterministic per dbname | Re-provisioning a reused tenant name fails with unique_violation | **`d00100631`** teardown cleans part_config(+sub); 434 orphans purged |
+| 10 | `idle_session_timeout` (finding-1 mitigation) reaps ANY long-idle client | killed the churn driver; would kill LISTEN clients lacking reconnect | Server listener already reconnects; driver fixed (**`073f8bd58`**); documented as an ops tradeoff |
+| 11 | `flushService` cleared ALL `bp:` instances on ANY `schema:update`, and the immediate rebuild raced evicted-but-DRAINING instances whose heap was still live (invisible to count-based headroom) | Every tenant PROVISION cold-restarted the whole pooled fleet; rebuild transient stacked on ~GB of draining heap → SIGABRT at 3584MB (killed soak attempt 2 at hour 2) | **`65c3056f9`** surgical per-database flush (`PoolDecision.databaseId` stamped at memoization; only the changed DB's decisions + blueprint invalidated; provisions are no-ops for resident blueprints) + drain-aware build admission (`waitForDrainSettle` after headroom eviction). Validated live: soak attempt 3 survived three provision/drop cycles at the exact event that killed attempt 2 |
+
+Also validated en route: bleed sentinel NEVER fired across the entire program
+(hundreds of thousands of authenticated cross-tenant-adjacent requests, thrash
+included) — pooling isolation held under every regime tested.
+
+## Prior banked results (pre-V1, same branch)
+
+Pooling correctness: SDL byte-identical pooled-vs-dedicated; engine-level zero-bleed;
+HTTP-authenticated zero-bleed (interleaved sessions + cross-token control); 7
+same-shape tenants → 1 build; RSS 1475MB (6 per-tenant instances) → 711MB (pooled,
+8 tenants); collision linter + shape fingerprint + safety fallbacks (realtime,
+empty-schema, name-collision, transient probe); W3 login fix (`public` appended to
+pooled search_path); plugin audit with fixes (i18n RLS bypass, search adapters,
+LLM/RAG, presigned-url, meta-schema caches).
+
+## Reproduction quickstart
+
+```
+# fleet + validation rig (isolated PG :5433)
+node scripts/scale-validate/tenant-factory.mjs --count N --prefix factory
+node scripts/scale-validate/drift-tenants.mjs --groups 4 --per-group 2 --column-drift 2
+node scripts/scale-validate/fleet.mjs --like '%' --out fleet-all.json   # filter nulls → fleet.json
+node scripts/scale-validate/canary-seed.mjs --fleet fleet.json
+node scripts/scale-validate/subset-fleet.mjs ...                        # k/tenant subsets
+node scripts/scale-validate/v2-ramps.mjs --plan plans/v2-2048-tuned.json --out out/results.jsonl
+node scripts/scale-validate/summarize-results.mjs out/results.jsonl
+node scripts/scale-validate/measure-instance-heap.mjs --label x --host api-...localhost
+```
+
+## V3 soak — final verdict: **PASS** (5-hour scope)
+
+Attempt 3, 2026-07-03 00:26→05:26 UTC, hardened build (findings 3/4/5/7/8/11 fixes
+in), heap 3584MB / instance estimate 1450MB → capacity R=2, 32-tenant same-shape
+fleet + auth at 30rps zipf, hourly relogin batches, provision+drop cycle every 2h,
+PG-side sampler recording. Scope note: the user shortened the planned 24h to 5h;
+all three prior attempts' failure modes fired inside 2h, so 5 clean hours is 2.5×
+past every observed failure point — but the original 12h/<5MB/h leak criterion was
+adapted to the 4h post-warmup window (below).
+
+| Criterion | Result | Verdict |
+|---|---|---|
+| No node/PG OOM, no crash, no restart | server up the full 5h; PG container ≤3153MB of 4.4GiB cap; backends ≤16 | ✅ |
+| Cross-tenant bleed | **0 violations** / 235 sentinel checks (469/470 own-canary seen; 1 inconclusive during the blip window) | ✅ |
+| Availability / latency | 392,794 requests completed, cumulative errRate **0.094%** (370 errors, ALL inside one ~2min recovery blip at the hour-2 provision/drop; every other window 0); overall p50/p95/p99 = **13/21/55ms** (steady windows p99 21–34ms) | ✅ |
+| Schema-churn survival (finding 11 validation) | **3 provision/drop cycles + 5 hourly relogin batches survived live** (128 relogins, 0 auth failures); attempt 2 died at cycle 1 on the same event | ✅ |
+| Heap stability / leak | like-for-like (cache=2) heap plateaus at **~2.78GB ±45MB** with non-monotonic hour-over-hour floors → no detectable leak at 5h resolution; naive all-sample slope (481MB/h) is a state-mix artifact of cache 1↔2 transitions, not growth | ✅ (5h bound; 24h run would tighten below the original 5MB/h criterion) |
+| Counters clean | governor evictions 0, buildRefusals 0, drainTimeouts 0, buildWaitTimeouts 0, connGuard 0/0; lru=6 evictions + 8 builds vs **481,610 pooling attaches** (~60k:1 instance reuse) | ✅ |
+
+Ops observations (non-blocking): server SIGTERM→exit exceeded 30s under pooling
+(SIGKILL after data-plane stop is safe; document in runbooks). macOS `ps` RSS is
+not usable for leak detection under memory compression — use sampler `heapUsed`.
+Raw artifacts: `out/soak-results.json`, `out/soak-collector.json`,
+`out/metrics-soak.jsonl`, `out/pg-soak.jsonl`, `out/metrics-final.json`,
+`out/soak-{harness,churn,ops,server}.log`.
+
+## Tooling productionized
+
+The entire validation toolkit was ported to a reusable package:
+**`packages/perf-harness`** (`@constructive-io/perf-harness`, bins `perf-harness`/
+`cperf`) — fleet provision/drift/canary/teardown, load harness/churn, measure
+collector/pg/instance-heap, run ramp/soak (detached, ordered stop), report
+summarize/merge/predict, and `cperf regression run` comparing fresh runs against
+baselines banked from this program (21KB/row, capacity law, zero-marginal,
+thrash-not-crash, bleed=0). Hub-port guardrail built in (5432/3000-3002/9000
+refused without `--allow-hub`); credentials via `PERF_PASSWORD` only. 156 unit
+tests; smoke-tested against this soak's live data. See the package README for the
+"regression reappeared" quickstart. The `scripts/scale-validate/` originals remain
+as-run for provenance.
+
+## Status
+
+- V1 instrumentation+fleet ✅ · V2 limits discovery ✅ (`V2-RESULTS.md`) · V3 soak
+  **PASS** (above) · V4 sizing+hardening ✅ (`SIZING.md`, fixes in the findings
+  table, perf-harness package).
+- Deep-scenario regression suite (`cperf regression run --suite deep`) added to cover the
+  four previously-untested scaling axes — **multi-API residency**, **settings-variant
+  splits**, **realtime dedicated cost**, and **partition creep** (each mutates the rig
+  under guaranteed teardown); code + baselines landed, **live results pending** (run by
+  the lead in the live phase).
+- All work is local to `feat/scale-phase0`; nothing pushed.
+
+## 2026-07-06 — Capacity-10× + ship-validation program (introspection filter, churn fix, compliance audit)
+
+Question under test: *can one node host the whole tenant fleet under real client
+traffic without crashing, and what is the memory footprint at 2GB / N GB?*
+
+**Headline (a3-day-clean, final ship tree):** 47 authenticated tenants, zipf @50rps,
+mixed read/write/meta, 30 minutes → **104,818/104,818 HTTP 200, errRate 0, p99 21ms,
+heap max 195.7MB of 2048MB (9.6%), RSS max 380MB, 0 evictions, 0 build refusals,
+115,907 pool-rewritten queries with 0 fail-closed, introspection filter 7/7 swaps,
+bleed 0.** (`out/a3-day-rerun-results.jsonl`; the earlier 0.22 errRate was fully
+attributed to a null-apiHost platform row in the fleet manifest — every error came
+from the harness fetching `http://null`; all real tenants had 0 errors.)
+
+Program evidence (perf-out/stress/, graded per-arm):
+- **Arm 1, pooling OFF**: 2048MB → SIGABRT; 3584MB → total thrash death (errRate 1.0,
+  964 evictions). The regression is real: dedicated instances cannot host a fleet at
+  the 61k-row catalog.
+- **Arm 2, pooled unfiltered**: 2048MB OOM on concurrent api+auth cold builds —
+  knife-edge; pooling needs the filter at production heap sizes.
+- **Arm 3, pooled + `GRAPHILE_INTROSPECTION_FILTER=1`**: k1–k5 blueprint diversity all
+  healthy at 2048MB (errRate 0, heap 131–167MB, 0 evictions); 900s storm errRate 0;
+  cold-burst 5/5 < 700ms; 187rps sustained; zero marginal heap per tenant.
+- **Constants transformed** (SDL byte-identical, MD5): instance 1305.6→14.7MB
+  (21.9→0.24KB per pg_class row, 87×), cold build 7165→417ms (17×), PG introspection
+  spike +1283→+17MiB, realtime dedicated 2596→14.7MB (176×). See SIZING.md
+  (2026-07-06 section) for the updated capacity law and knobs; floor is 1024MB heap.
+- **Eviction-churn OOM found + fixed (`46636d4b4`)**: the build-wait Promise.race
+  armed a 180s timer per waiting request and never cleared it on build success —
+  every evicted ~15MB instance stayed reachable for 180s, so forced max=1 churn
+  OOM-killed a 2GB heap in 65s (heap-snapshot proven; post-timer-expiry memory
+  collapsed 1766→52.9MB). Fixed with raceBuildAgainstTimeout() + made the
+  heap-pressure governor reachable (ratio vs V8's exhaustible headroom, not
+  heap_size_limit) + in-critical-section refusal (503) + 250ms build spacing under
+  elevated pressure. Post-fix: worst-case all-miss churn at 2048MB is a bounded
+  sawtooth at 23 builds/s with clean recovery; capacity+1 rotation sustains
+  1444/1444 OK.
+- **1h churn soak**: 9 provision/drop cycles, RSS slope +8.3MB/h, 0 bleed, rewrite
+  pool 0 fail-closed over 103,384 queries. pg_class +189 residue explained: 21
+  orphaned `partman.template_*` tables per dropped tenant (teardown follow-up noted).
+- **CTO compliance audit (4 lenses + adversarial verify, perf-out/cto-audit-result.json)**:
+  search_path ZERO in product code; identifier emission fully qualified (no
+  pgIdentifiers overrides; upstream default verified); 13/13 scope-pollution checks
+  clean (transaction-local GUCs, per-tenant prepared-statement namespacing +
+  DEALLOCATE, LISTEN on a dedicated client, tenant-keyed caches). One blocker found
+  and fixed (`e38f4b52d`): settings-query detection now byte-matches the adaptor's
+  statement text instead of trusting bind-value shape. Credential literal purged
+  from unpushed history (base untouched — normal push).
+
+Verdict: **SHIP.** All gates pass on the final tree; remaining advisories (bm25
+index name under pooling, PublicKeySignature withPgClient(null) — preexisting,
+partman template teardown) are documented follow-ups, none load-bearing.
diff --git a/scripts/scale-validate/_lib.mjs b/scripts/scale-validate/_lib.mjs
new file mode 100644
index 0000000000..133bf79cf3
--- /dev/null
+++ b/scripts/scale-validate/_lib.mjs
@@ -0,0 +1,456 @@
+/**
+ * Shared helpers for the scale-validate harness v2 (Task B).
+ *
+ * Pure tooling — no server/package code is imported at module load beyond `pg`
+ * (resolved via the @dataplan/pg chain, exactly like scripts/scale-spike).
+ * Every script imports from here; each script stays independently runnable via
+ *   node scripts/scale-validate/<script>.mjs
+ */
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import fs from 'node:fs';
+import path from 'path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const WORKTREE = path.resolve(__dirname, '..', '..');
+
+// ---------------------------------------------------------------------------
+// pg resolution
+// ---------------------------------------------------------------------------
+// `pg` is not a direct dep of the worktree root, but it is present in the pnpm
+// store reachable through the @dataplan/pg dependency chain (same trick the
+// scale-spike scripts use).
+export function resolvePg() {
+  const req = createRequire(path.join(WORKTREE, 'graphql', 'query', 'package.json'));
+  const reqAdaptor = createRequire(req.resolve('postgraphile/adaptors/pg'));
+  const reqDataplan = createRequire(reqAdaptor.resolve('@dataplan/pg'));
+  return reqDataplan('pg');
+}
+
+// ---------------------------------------------------------------------------
+// Postgres connection config
+// ---------------------------------------------------------------------------
+// Defaults target the isolated dev database on :5433. CLI flags win over env,
+// env wins over defaults. We NEVER default to 5432.
+export function pgConfigFromArgs(args = {}) {
+  const num = (v, d) => {
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : d;
+  };
+  return {
+    host: args['pg-host'] || process.env.PGHOST || 'localhost',
+    port: num(args['pg-port'] ?? process.env.PGPORT, 5433),
+    user: args['pg-user'] || process.env.PGUSER || 'postgres',
+    password: args['pg-password'] ?? process.env.PGPASSWORD ?? 'password',
+    database: args['pg-database'] || process.env.PGDATABASE || 'constructive'
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Minimal arg parsing: --flag value | --flag=value | --flag (boolean true)
+// ---------------------------------------------------------------------------
+export function parseArgs(argv) {
+  const args = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq !== -1) {
+        args[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const key = a.slice(2);
+        const next = argv[i + 1];
+        if (next === undefined || next.startsWith('--')) {
+          args[key] = true;
+        } else {
+          args[key] = next;
+          i++;
+        }
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { args, positional };
+}
+
+export function asBool(v, dflt = false) {
+  if (v === undefined || v === null) return dflt;
+  if (typeof v === 'boolean') return v;
+  const s = String(v).toLowerCase();
+  return s === '1' || s === 'true' || s === 'yes' || s === 'on';
+}
+
+export function asInt(v, dflt) {
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) ? n : dflt;
+}
+
+export function asFloat(v, dflt) {
+  const n = Number.parseFloat(v);
+  return Number.isFinite(n) ? n : dflt;
+}
+
+export const nowIso = () => new Date().toISOString();
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export const round2 = (n) => Math.round(n * 100) / 100;
+
+// Seedable RNG (mulberry32) for reproducible shape/tenant selection.
+export function makeRng(seed) {
+  let a = (seed >>> 0) || 0x9e3779b9;
+  return function rng() {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Fleet manifest
+// ---------------------------------------------------------------------------
+export function loadFleet(fleetPath) {
+  const raw = fs.readFileSync(fleetPath, 'utf8');
+  const parsed = JSON.parse(raw);
+  const tenants = Array.isArray(parsed) ? parsed : parsed.tenants;
+  if (!Array.isArray(tenants) || tenants.length === 0) {
+    throw new Error(`fleet file ${fleetPath} has no tenants`);
+  }
+  return { manifest: parsed, tenants };
+}
+
+// The token used inside CANARY-<token> rows. MUST match between canary-seed.mjs
+// and the harness sentinel so bleed can be attributed to a foreign tenant.
+export const canaryToken = (tenant) => tenant.dbname;
+export const canaryName = (tenant) => `CANARY-${canaryToken(tenant)}`;
+export const CANARY_PREFIX = 'CANARY-';
+
+// ---------------------------------------------------------------------------
+// GraphQL over HTTP
+// ---------------------------------------------------------------------------
+// We put the tenant host in the URL (e.g. api-xxx.localhost) because undici
+// ignores an explicit `host` header. `*.localhost` resolves to loopback, so the
+// connection lands on 127.0.0.1 while the server sees the correct Host header
+// for subdomain routing.
+export async function gqlFetch({ host, port, query, variables, token, timeoutMs = 30000, gqlPath = '/graphql' }) {
+  const url = `http://${host}:${port}${gqlPath}`;
+  const headers = { 'content-type': 'application/json', accept: 'application/json' };
+  if (token) headers.authorization = `Bearer ${token}`;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  const start = performance.now();
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(variables ? { query, variables } : { query }),
+      signal: ac.signal
+    });
+    const elapsedMs = performance.now() - start;
+    const ct = res.headers.get('content-type') || '';
+    let json = null;
+    let text = null;
+    if (ct.includes('json')) {
+      json = await res.json().catch(() => null);
+    } else {
+      text = await res.text().catch(() => null);
+      // Some error paths return JSON without the header — try to parse.
+      if (text) {
+        try { json = JSON.parse(text); } catch { /* not json */ }
+      }
+    }
+    return { status: res.status, ok: res.ok, json, text, elapsedMs, error: null };
+  } catch (err) {
+    const elapsedMs = performance.now() - start;
+    const error = err && err.name === 'AbortError' ? 'timeout' : (err && (err.code || err.message)) || 'network';
+    return { status: 0, ok: false, json: null, text: null, elapsedMs, error };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function isRotating(resp) {
+  if (resp.status === 503) {
+    const code = resp.json && resp.json.error && resp.json.error.code;
+    return code === 'SERVICE_ROTATING' || true; // any 503 counts as rotating
+  }
+  return false;
+}
+
+export function gqlErrors(resp) {
+  return (resp.json && Array.isArray(resp.json.errors)) ? resp.json.errors : [];
+}
+
+export function isUnauthenticated(resp) {
+  const errs = gqlErrors(resp);
+  for (const e of errs) {
+    const code = e && e.extensions && e.extensions.code;
+    if (code === 'UNAUTHENTICATED' || code === 'FORBIDDEN') return true;
+    const msg = (e && e.message) || '';
+    if (/unauthenticated|not authori[sz]ed|permission denied|jwt|login required|invalid token|expired/i.test(msg)) return true;
+  }
+  if (resp.status === 401 || resp.status === 403) return true;
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Introspection helpers (operate on the JSON introspection result)
+// ---------------------------------------------------------------------------
+export const INTROSPECTION_QUERY = `query Introspect {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    types {
+      kind
+      name
+      fields(includeDeprecated: true) { name args { name type { ...T } } type { ...T } }
+      inputFields { name type { ...T } }
+    }
+  }
+}
+fragment T on __Type {
+  kind name
+  ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name } } } } }
+}`;
+
+export function unwrapType(ref) {
+  let t = ref;
+  while (t && t.ofType) t = t.ofType;
+  return t || null;
+}
+
+export function isNonNull(ref) {
+  return !!(ref && ref.kind === 'NON_NULL');
+}
+
+export function buildTypeIndex(introspect) {
+  const index = new Map();
+  const schema = introspect && introspect.__schema;
+  if (!schema) return { index, queryType: null, mutationType: null };
+  for (const t of schema.types) index.set(t.name, t);
+  return {
+    index,
+    queryType: schema.queryType && schema.queryType.name,
+    mutationType: schema.mutationType && schema.mutationType.name
+  };
+}
+
+function findConnectionField(index, queryTypeName, re) {
+  const qt = index.get(queryTypeName);
+  if (!qt) return null;
+  const candidates = (qt.fields || []).filter((f) => re.test(f.name));
+  for (const f of candidates) {
+    const named = unwrapType(f.type);
+    const nt = named && index.get(named.name);
+    if (nt && (nt.fields || []).some((sf) => sf.name === 'nodes')) return f.name;
+  }
+  return candidates[0] ? candidates[0].name : null;
+}
+
+const SCALAR_SAMPLE = (scalar, rand) => {
+  switch (scalar) {
+    case 'Int':
+    case 'BigInt':
+      return 0;
+    case 'Float':
+    case 'BigFloat':
+      return 0;
+    case 'Boolean':
+      return true;
+    default:
+      return `load-${rand}`;
+  }
+};
+
+// Discover create/delete/read/meta operations from an introspection result.
+export function discoverOps(introspect) {
+  const { index, queryType, mutationType } = buildTypeIndex(introspect);
+  const out = { queryType, mutationType, read: null, meta: false, create: null, del: null };
+  if (!queryType) return out;
+
+  // read (categories connection)
+  out.read = findConnectionField(index, queryType, /categor/i);
+
+  // meta (_meta { tables { name } })
+  const qt = index.get(queryType);
+  out.meta = !!(qt && (qt.fields || []).some((f) => f.name === '_meta'));
+
+  if (!mutationType) return out;
+  const mt = index.get(mutationType);
+
+  // delete mutation (prefer PK id-based over nodeId-based)
+  const delField = (mt.fields || []).find((f) => /^delete.*categor/i.test(f.name) && !/nodeid/i.test(f.name))
+    || (mt.fields || []).find((f) => /^delete.*categor/i.test(f.name));
+  if (delField) {
+    const inputArg = (delField.args || []).find((a) => a.name === 'input');
+    if (inputArg) {
+      const inputType = index.get(unwrapType(inputArg.type).name);
+      const innerFields = (inputType.inputFields || []).map((f) => ({ name: f.name, typeName: unwrapType(f.type).name }));
+      const byId = innerFields.find((f) => f.name === 'id');
+      const byNodeId = innerFields.find((f) => f.name === 'nodeId');
+      const key = byId ? 'id' : (byNodeId ? 'nodeId' : (innerFields[0] && innerFields[0].name));
+      if (key) {
+        out.del = { name: delField.name, inputTypeName: unwrapType(inputArg.type).name, key };
+      }
+    }
+  }
+
+  // create mutation
+  const createField = (mt.fields || []).find((f) => /^create.*categor/i.test(f.name));
+  if (createField) {
+    const inputArg = (createField.args || []).find((a) => a.name === 'input');
+    if (inputArg) {
+      const inputTypeName = unwrapType(inputArg.type).name;
+      const inputType = index.get(inputTypeName);
+      const innerField = (inputType.inputFields || []).find((f) => {
+        const nt = index.get(unwrapType(f.type).name);
+        return nt && nt.kind === 'INPUT_OBJECT';
+      });
+      if (innerField) {
+        const innerType = index.get(unwrapType(innerField.type).name);
+        const requiredScalars = (innerType.inputFields || [])
+          .filter((f) => isNonNull(f.type))
+          .map((f) => ({ name: f.name, scalar: unwrapType(f.type).name, kind: unwrapType(f.type).kind }))
+          .filter((f) => f.kind === 'SCALAR' || f.kind === 'ENUM');
+        const payloadType = index.get(unwrapType(createField.type).name);
+        const payloadField = (payloadType.fields || []).find((f) => {
+          const nt = index.get(unwrapType(f.type).name);
+          return nt && nt.kind === 'OBJECT' && /categor/i.test(nt.name) && (nt.fields || []).some((sf) => sf.name === 'id');
+        });
+        out.create = {
+          name: createField.name,
+          inputTypeName,
+          innerName: innerField.name,
+          requiredScalars,
+          payloadFieldName: payloadField ? payloadField.name : null,
+          // which key to select in the payload so we can delete afterwards
+          keySelect: out.del ? out.del.key : 'id'
+        };
+      }
+    }
+  }
+  return out;
+}
+
+// Build the record input object for a create write. `nameValue` is forced onto
+// the `name` column; everything else required gets a type-appropriate value.
+export function buildCreateRecord(create, nameValue, rand) {
+  const rec = {};
+  for (const f of create.requiredScalars) {
+    if (f.name === 'name') rec[f.name] = nameValue;
+    else if (f.name === 'slug') rec[f.name] = `load-${rand}`;
+    else rec[f.name] = SCALAR_SAMPLE(f.scalar, rand);
+  }
+  if (rec.name === undefined) rec.name = nameValue; // ensure name present even if not flagged required
+  return rec;
+}
+
+// ---------------------------------------------------------------------------
+// Bucketed latency histogram (bounded memory — safe for multi-hour soaks)
+// ---------------------------------------------------------------------------
+const DEFAULT_BUCKETS = [
+  1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610,
+  1000, 1600, 2600, 4200, 6800, 11000, 18000, 30000, 60000
+];
+
+export class Histogram {
+  constructor(buckets = DEFAULT_BUCKETS) {
+    this.buckets = buckets;
+    this.counts = new Array(buckets.length + 1).fill(0);
+    this.count = 0;
+    this.sum = 0;
+    this.min = Infinity;
+    this.max = 0;
+  }
+
+  record(ms) {
+    this.count++;
+    this.sum += ms;
+    if (ms < this.min) this.min = ms;
+    if (ms > this.max) this.max = ms;
+    let i = 0;
+    while (i < this.buckets.length && ms > this.buckets[i]) i++;
+    this.counts[i]++;
+  }
+
+  percentile(p) {
+    if (this.count === 0) return 0;
+    const target = Math.ceil((p / 100) * this.count);
+    let cum = 0;
+    for (let i = 0; i < this.counts.length; i++) {
+      cum += this.counts[i];
+      if (cum >= target) {
+        return i < this.buckets.length ? this.buckets[i] : Math.round(this.max);
+      }
+    }
+    return Math.round(this.max);
+  }
+
+  summary() {
+    return {
+      count: this.count,
+      min: this.count ? round2(this.min) : 0,
+      mean: this.count ? round2(this.sum / this.count) : 0,
+      p50: this.percentile(50),
+      p95: this.percentile(95),
+      p99: this.percentile(99),
+      max: round2(this.max)
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Shape samplers over the tenant array
+// ---------------------------------------------------------------------------
+// zipf: weight_i = 1 / (i + 1) over fleet order; returns index sampler.
+export function makeZipfSampler(n, rng) {
+  const weights = [];
+  let total = 0;
+  for (let i = 0; i < n; i++) {
+    const w = 1 / (i + 1);
+    weights.push(w);
+    total += w;
+  }
+  const cum = [];
+  let acc = 0;
+  for (let i = 0; i < n; i++) {
+    acc += weights[i] / total;
+    cum.push(acc);
+  }
+  return () => {
+    const r = rng();
+    for (let i = 0; i < n; i++) if (r <= cum[i]) return i;
+    return n - 1;
+  };
+}
+
+export function makeMixSampler(mixStr, rng) {
+  // "read:0.7,write:0.25,meta:0.05"
+  const entries = [];
+  let total = 0;
+  for (const part of String(mixStr).split(',')) {
+    const [k, v] = part.split(':');
+    const w = Number.parseFloat(v);
+    if (k && Number.isFinite(w) && w > 0) {
+      entries.push([k.trim(), w]);
+      total += w;
+    }
+  }
+  if (entries.length === 0) {
+    entries.push(['read', 1]);
+    total = 1;
+  }
+  const cum = [];
+  let acc = 0;
+  for (const [k, w] of entries) {
+    acc += w / total;
+    cum.push([k, acc]);
+  }
+  return () => {
+    const r = rng();
+    for (const [k, c] of cum) if (r <= c) return k;
+    return cum[cum.length - 1][0];
+  };
+}
diff --git a/scripts/scale-validate/canary-seed.mjs b/scripts/scale-validate/canary-seed.mjs
new file mode 100644
index 0000000000..20239e126d
--- /dev/null
+++ b/scripts/scale-validate/canary-seed.mjs
@@ -0,0 +1,159 @@
+/**
+ * canary-seed.mjs — seed one CANARY-<dbname> row into each tenant's
+ * app-public.categories table (superuser pg client). Idempotent.
+ *
+ * The harness bleed-sentinel reads a tenant's categories and FAILS HARD if it
+ * ever sees a CANARY-<other-dbname> row — so these rows must exist for the
+ * sentinel to have anything to detect cross-tenant bleed with.
+ *
+ * NOT NULL columns without a default are discovered via information_schema and
+ * filled (name -> the canary name, slug/other text -> a canary slug).
+ *
+ * Usage:
+ *   node scripts/scale-validate/canary-seed.mjs --fleet fleet.json
+ *   node scripts/scale-validate/canary-seed.mjs --fleet fleet.json --cleanup
+ */
+import { asBool, canaryName, canaryToken, loadFleet, parseArgs, pgConfigFromArgs, resolvePg } from './_lib.mjs';
+
+const HELP = `canary-seed.mjs — insert/remove CANARY-<dbname> rows in each tenant's categories
+
+Options:
+  --fleet <file>   fleet manifest from fleet.mjs (required)
+  --table <name>   target table (default: categories)
+  --cleanup        remove the canary rows instead of inserting
+  --pg-* / PG*     connection overrides
+  --help
+`;
+
+const REQUIRED_COLS_SQL = `
+SELECT column_name, data_type, udt_name
+FROM information_schema.columns
+WHERE table_schema = $1 AND table_name = $2
+  AND is_nullable = 'NO'
+  AND column_default IS NULL
+ORDER BY ordinal_position;
+`;
+
+const TABLE_EXISTS_SQL = `
+SELECT 1 FROM information_schema.tables
+WHERE table_schema = $1 AND table_name = $2 AND table_type = 'BASE TABLE';
+`;
+
+function valueForColumn(col, nameValue, slugValue) {
+  if (col.column_name === 'name') return nameValue;
+  if (col.column_name === 'slug') return slugValue;
+  const t = (col.data_type || '').toLowerCase();
+  const u = (col.udt_name || '').toLowerCase();
+  if (t.includes('char') || t === 'text' || u === 'citext') return slugValue;
+  if (t.includes('bool')) return true;
+  if (t.includes('int') || t === 'numeric' || t.includes('double') || t.includes('real')) return 0;
+  // Unknown required column type we cannot safely synthesize.
+  return undefined;
+}
+
+async function main() {
+  const { args } = parseArgs(process.argv.slice(2));
+  if (asBool(args.help) || !args.fleet) {
+    process.stdout.write(HELP);
+    if (!args.fleet && !asBool(args.help)) process.exitCode = 1;
+    return;
+  }
+  const table = typeof args.table === 'string' ? args.table : 'categories';
+  const cleanup = asBool(args.cleanup);
+  const { tenants } = loadFleet(args.fleet);
+  const cfg = pgConfigFromArgs(args);
+  const { Client } = resolvePg();
+  const client = new Client(cfg);
+  await client.connect();
+
+  const report = { table, mode: cleanup ? 'cleanup' : 'seed', results: [] };
+  try {
+    for (const t of tenants) {
+      const schema = t.appPublicSchema;
+      const entry = { dbname: t.dbname, schema, status: 'ok' };
+      if (!schema) {
+        entry.status = 'skipped';
+        entry.reason = 'no app-public schema';
+        report.results.push(entry);
+        continue;
+      }
+      const exists = await client.query(TABLE_EXISTS_SQL, [schema, table]);
+      if (exists.rowCount === 0) {
+        entry.status = 'skipped';
+        entry.reason = `no ${table} table (blank tenant)`;
+        report.results.push(entry);
+        continue;
+      }
+
+      const name = canaryName(t);
+      const slug = `canary-${canaryToken(t)}`.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+      const qSchema = `"${schema}"`;
+      const qTable = `"${table}"`;
+
+      if (cleanup) {
+        const del = await client.query(`DELETE FROM ${qSchema}.${qTable} WHERE name = $1`, [name]);
+        entry.removed = del.rowCount;
+        report.results.push(entry);
+        continue;
+      }
+
+      // Idempotent: skip if a canary row already exists.
+      const already = await client.query(
+        `SELECT count(*)::int AS n FROM ${qSchema}.${qTable} WHERE name = $1`, [name]);
+      if (already.rows[0].n > 0) {
+        entry.status = 'exists';
+        entry.inserted = 0;
+        report.results.push(entry);
+        continue;
+      }
+
+      const cols = await client.query(REQUIRED_COLS_SQL, [schema, table]);
+      const colNames = [];
+      const values = [];
+      const placeholders = [];
+      let bad = null;
+      let idx = 1;
+      const seen = new Set();
+      for (const col of cols.rows) {
+        const v = valueForColumn(col, name, slug);
+        if (v === undefined) { bad = col.column_name; break; }
+        colNames.push(`"${col.column_name}"`);
+        values.push(v);
+        placeholders.push(`$${idx++}`);
+        seen.add(col.column_name);
+      }
+      // Ensure `name` is always written even if it was not flagged required.
+      if (!seen.has('name')) {
+        colNames.push('"name"');
+        values.push(name);
+        placeholders.push(`$${idx++}`);
+      }
+      if (bad) {
+        entry.status = 'skipped';
+        entry.reason = `unsupported required column: ${bad}`;
+        report.results.push(entry);
+        continue;
+      }
+      const ins = await client.query(
+        `INSERT INTO ${qSchema}.${qTable} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`,
+        values);
+      entry.inserted = ins.rowCount;
+      entry.name = name;
+      report.results.push(entry);
+    }
+  } finally {
+    await client.end();
+  }
+
+  const seeded = report.results.filter((r) => r.inserted > 0).length;
+  const existed = report.results.filter((r) => r.status === 'exists').length;
+  const removed = report.results.reduce((a, r) => a + (r.removed || 0), 0);
+  const skipped = report.results.filter((r) => r.status === 'skipped').length;
+  report.summary = { seeded, existed, removed, skipped, tenants: tenants.length };
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+}
+
+main().catch((err) => {
+  process.stderr.write(`[canary-seed] ERROR: ${err && err.stack ? err.stack : err}\n`);
+  process.exitCode = 1;
+});
diff --git a/scripts/scale-validate/churn-driver.mjs b/scripts/scale-validate/churn-driver.mjs
new file mode 100644
index 0000000000..4afb1ca9c2
--- /dev/null
+++ b/scripts/scale-validate/churn-driver.mjs
@@ -0,0 +1,116 @@
+/**
+ * churn-driver.mjs — drive schema-cache churn during a soak.
+ *
+ * Every --interval-notify-sec it issues a NOTIFY on channel "schema:update"
+ * (via pg_notify) with a random tenant's databaseId as payload. The server
+ * LISTENs on "schema:update" and flushes that database's cached PostGraphile
+ * instance(s), forcing rebuilds — exercising eviction/drain/build paths.
+ *
+ * A provisioning hook fires every --provision-every-sec but only logs a marker;
+ * actual tenant provisioning is handled separately by the orchestrator.
+ *
+ * Timeline events are emitted as JSON lines to stdout.
+ *
+ * Usage:
+ *   node scripts/scale-validate/churn-driver.mjs --fleet fleet.json \
+ *     --interval-notify-sec 20 --provision-every-sec 300 --duration-sec 3600
+ */
+import { asBool, asInt, loadFleet, nowIso, parseArgs, pgConfigFromArgs, resolvePg } from './_lib.mjs';
+
+const HELP = `churn-driver.mjs — NOTIFY schema:update churn + provisioning markers
+
+Options:
+  --fleet <file>              fleet manifest (required)
+  --interval-notify-sec <n>   NOTIFY period (default 20; 0 disables)
+  --provision-every-sec <n>   provisioning-marker period (default 0 = off)
+  --duration-sec <n>          run length (default 3600; 0 = until SIGINT)
+  --channel <name>            notify channel (default schema:update)
+  --seed <n>                  RNG seed
+  --pg-* / PG*                connection overrides
+  --help
+`;
+
+async function main() {
+  const { args } = parseArgs(process.argv.slice(2));
+  if (asBool(args.help) || !args.fleet) {
+    process.stdout.write(HELP);
+    if (!args.fleet && !asBool(args.help)) process.exitCode = 1;
+    return;
+  }
+  const intervalNotifySec = asInt(args['interval-notify-sec'], 20);
+  const provisionEverySec = asInt(args['provision-every-sec'], 0);
+  const durationSec = asInt(args['duration-sec'], 3600);
+  const channel = typeof args.channel === 'string' ? args.channel : 'schema:update';
+  let seed = asInt(args.seed, (Date.now() & 0x7fffffff));
+  const { tenants } = loadFleet(args.fleet);
+  const cfg = pgConfigFromArgs(args);
+  const { Client } = resolvePg();
+  // Fresh connection per query: with long NOTIFY intervals a persistent client
+  // gets reaped by idle_session_timeout (57P05) and its socket error would
+  // kill the driver mid-soak. Hourly connects are free.
+  const withClient = async (fn) => {
+    const client = new Client(cfg);
+    client.on('error', () => {});
+    await client.connect();
+    try {
+      return await fn(client);
+    } finally {
+      try {
+        await client.end();
+      } catch {
+        /* ignore */
+      }
+    }
+  };
+
+  const emit = (obj) => process.stdout.write(`${JSON.stringify({ at: nowIso(), ...obj })}\n`);
+  const rand = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+  const pickTenant = () => tenants[Math.floor(rand() * tenants.length)];
+
+  let notifies = 0;
+  let provisions = 0;
+  let failures = 0;
+  const timers = [];
+
+  emit({ t: 'start', channel, intervalNotifySec, provisionEverySec, durationSec, tenants: tenants.length, pid: process.pid });
+
+  if (intervalNotifySec > 0) {
+    timers.push(setInterval(async () => {
+      const tenant = pickTenant();
+      try {
+        await withClient((client) => client.query('SELECT pg_notify($1, $2)', [channel, tenant.databaseId]));
+        notifies++;
+        emit({ t: 'notify', channel, databaseId: tenant.databaseId, dbname: tenant.dbname, seq: notifies });
+      } catch (err) {
+        failures++;
+        emit({ t: 'notify-error', databaseId: tenant.databaseId, dbname: tenant.dbname, error: String(err && err.message || err) });
+      }
+    }, intervalNotifySec * 1000));
+  }
+
+  if (provisionEverySec > 0) {
+    timers.push(setInterval(() => {
+      provisions++;
+      // Provisioning hook — the orchestrator performs the real provision; we only
+      // mark the timeline so churn events can be correlated.
+      emit({ t: 'provision-marker', seq: provisions, note: 'provisioning handled by orchestrator' });
+    }, provisionEverySec * 1000));
+  }
+
+  const stop = async (reason) => {
+    for (const t of timers) clearInterval(t);
+    emit({ t: 'stop', reason, notifies, provisions, failures });
+    // per-query connections — nothing persistent to close
+  };
+
+  let stopTimer = null;
+  if (durationSec > 0) stopTimer = setTimeout(() => stop('duration'), durationSec * 1000);
+  const onSig = async () => { if (stopTimer) clearTimeout(stopTimer); await stop('signal'); process.exit(0); };
+  process.on('SIGINT', onSig);
+  process.on('SIGTERM', onSig);
+}
+
+main().catch((err) => {
+  process.stderr.write(`[churn] FATAL: ${err && err.stack ? err.stack : err}\n`);
+  process.exitCode = 1;
+});
diff --git a/scripts/scale-validate/collector.mjs b/scripts/scale-validate/collector.mjs
new file mode 100644
index 0000000000..d370a6470a
--- /dev/null
+++ b/scripts/scale-validate/collector.mjs
@@ -0,0 +1,207 @@
+/**
+ * collector.mjs — RSS sampler + server metrics tailer.
+ *
+ * Samples the server process RSS (ps -o rss=) every --interval-sec and tails the
+ * server's metrics.jsonl. At exit it computes:
+ *   - RSS min / max / final (MB)
+ *   - linear-regression slope (MB/hour) over the LAST HALF of the RSS samples
+ *   - eviction / drain / build totals parsed from the LAST metrics line
+ * and writes a summary JSON to --out.
+ *
+ * The metrics.jsonl schema is owned by the server instrumentation; this tailer
+ * is intentionally schema-tolerant: it flattens the last JSON object and picks
+ * the best numeric field per counter family (evict / drain / build).
+ *
+ * Exit is triggered by SIGINT/SIGTERM, by --duration-sec, or when the monitored
+ * PID disappears.
+ *
+ * Usage:
+ *   node scripts/scale-validate/collector.mjs --pid 12345 \
+ *     --metrics-file graphql/server/logs/metrics.jsonl --out collector.json
+ */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import { asInt, nowIso, parseArgs, round2, sleep } from './_lib.mjs';
+
+const HELP = `collector.mjs — sample RSS + tail metrics.jsonl, summarize at exit
+
+Options:
+  --pid <n>            server process id to sample (required)
+  --metrics-file <f>   server metrics.jsonl to tail (optional)
+  --interval-sec <n>   sample period (default 15)
+  --duration-sec <n>   run length (default 0 = until SIGINT or pid exit)
+  --out <file>         summary JSON (default collector.json)
+  --help
+`;
+
+function sampleRssMb(pid) {
+  const res = spawnSync('ps', ['-o', 'rss=', '-p', String(pid)], { encoding: 'utf8' });
+  if (res.status !== 0) return null;
+  const kb = Number.parseInt((res.stdout || '').trim(), 10);
+  if (!Number.isFinite(kb)) return null;
+  return round2(kb / 1024);
+}
+
+// Least-squares slope of y over x. Returns slope in y-units per x-unit.
+function linregSlope(points) {
+  const n = points.length;
+  if (n < 2) return 0;
+  let sx = 0, sy = 0, sxx = 0, sxy = 0;
+  for (const [x, y] of points) { sx += x; sy += y; sxx += x * x; sxy += x * y; }
+  const denom = n * sxx - sx * sx;
+  if (denom === 0) return 0;
+  return (n * sxy - sx * sy) / denom;
+}
+
+// Flatten nested object into [{ path, value }] for numeric leaves only.
+function flattenNumeric(obj, prefix = '', out = []) {
+  if (obj == null || typeof obj !== 'object') return out;
+  for (const [k, v] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${k}` : k;
+    if (typeof v === 'number' && Number.isFinite(v)) out.push({ path, value: v });
+    else if (v && typeof v === 'object') flattenNumeric(v, path, out);
+  }
+  return out;
+}
+
+// Pick the best-matching numeric field for a counter family.
+function pickCounter(flat, family) {
+  const re = new RegExp(family, 'i');
+  const candidates = flat.filter((f) => re.test(f.path));
+  if (candidates.length === 0) return { value: null, path: null, candidates: [] };
+  // Prefer explicit totals/counts, then longer (more specific) paths.
+  const score = (p) => (/(total|count|sum|cumulative|s$)/i.test(p) ? 2 : 0) + p.length / 1000;
+  candidates.sort((a, b) => score(b.path) - score(a.path));
+  return { value: candidates[0].value, path: candidates[0].path, candidates: candidates.map((c) => ({ path: c.path, value: c.value })) };
+}
+
+async function main() {
+  const { args } = parseArgs(process.argv.slice(2));
+  if (args.help || args.pid === undefined) {
+    process.stdout.write(HELP);
+    if (args.pid === undefined && !args.help) process.exitCode = 1;
+    return;
+  }
+  const pid = asInt(args.pid, 0);
+  const metricsFile = typeof args['metrics-file'] === 'string' ? args['metrics-file'] : null;
+  const intervalSec = asInt(args['interval-sec'], 15);
+  const durationSec = asInt(args['duration-sec'], 0);
+  const out = typeof args.out === 'string' ? args.out : 'collector.json';
+
+  const startMs = Date.now();
+  const samples = []; // { tSec, rssMb }
+  let lastMetricsObj = null;
+  let lastMetricsRaw = null;
+  let metricsLinesSeen = 0;
+  let metricsOffset = 0;
+  let stopping = false;
+  let stopReason = null;
+
+  const readMetricsTail = () => {
+    if (!metricsFile) return;
+    let stat;
+    try { stat = fs.statSync(metricsFile); } catch { return; }
+    if (stat.size < metricsOffset) metricsOffset = 0; // rotated/truncated
+    if (stat.size === metricsOffset) return;
+    let chunk = '';
+    try {
+      const fd = fs.openSync(metricsFile, 'r');
+      const len = stat.size - metricsOffset;
+      const buf = Buffer.alloc(len);
+      fs.readSync(fd, buf, 0, len, metricsOffset);
+      fs.closeSync(fd);
+      chunk = buf.toString('utf8');
+      metricsOffset = stat.size;
+    } catch { return; }
+    for (const line of chunk.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      metricsLinesSeen++;
+      try {
+        lastMetricsObj = JSON.parse(trimmed);
+        lastMetricsRaw = trimmed;
+      } catch { /* partial/non-json line — ignore */ }
+    }
+  };
+
+  const emit = (obj) => process.stdout.write(`${JSON.stringify({ at: nowIso(), ...obj })}\n`);
+  emit({ t: 'start', pid, metricsFile, intervalSec, durationSec });
+
+  const finalize = () => {
+    const rssValues = samples.map((s) => s.rssMb);
+    const rssMin = rssValues.length ? Math.min(...rssValues) : null;
+    const rssMax = rssValues.length ? Math.max(...rssValues) : null;
+    const rssFinal = rssValues.length ? rssValues[rssValues.length - 1] : null;
+    // slope over the last half of samples
+    const half = samples.slice(Math.floor(samples.length / 2));
+    const slopeMbPerSec = linregSlope(half.map((s) => [s.tSec, s.rssMb]));
+    const slopeMbPerHour = round2(slopeMbPerSec * 3600);
+
+    const flat = lastMetricsObj ? flattenNumeric(lastMetricsObj) : [];
+    const evictions = pickCounter(flat, 'evict');
+    const drains = pickCounter(flat, 'drain');
+    const builds = pickCounter(flat, 'build');
+
+    const summary = {
+      generatedAt: nowIso(),
+      pid,
+      stopReason,
+      durationSec: round2((Date.now() - startMs) / 1000),
+      intervalSec,
+      rss: {
+        samples: samples.length,
+        minMb: rssMin,
+        maxMb: rssMax,
+        finalMb: rssFinal,
+        slopeMbPerHour,
+        slopeBasis: `last ${half.length} of ${samples.length} samples`,
+        series: samples
+      },
+      metrics: {
+        file: metricsFile,
+        linesSeen: metricsLinesSeen,
+        evictionsTotal: evictions.value,
+        evictionsField: evictions.path,
+        drainsTotal: drains.value,
+        drainsField: drains.path,
+        buildsTotal: builds.value,
+        buildsField: builds.path,
+        candidates: { evict: evictions.candidates, drain: drains.candidates, build: builds.candidates },
+        lastLine: lastMetricsObj
+      }
+    };
+    fs.writeFileSync(out, `${JSON.stringify(summary, null, 2)}\n`);
+    emit({
+      t: 'summary', rssMinMb: rssMin, rssMaxMb: rssMax, rssFinalMb: rssFinal, slopeMbPerHour,
+      evictionsTotal: evictions.value, drainsTotal: drains.value, buildsTotal: builds.value, out
+    });
+    return summary;
+  };
+
+  const onSig = () => { stopping = true; stopReason = stopReason || 'signal'; };
+  process.on('SIGINT', onSig);
+  process.on('SIGTERM', onSig);
+
+  // Prime the metrics offset so we start reading from current EOF-ish but still
+  // capture the last line: read everything once so lastMetricsObj is populated.
+  readMetricsTail();
+
+  while (!stopping) {
+    const rssMb = sampleRssMb(pid);
+    if (rssMb == null) { stopReason = 'pid-exited'; break; }
+    samples.push({ tSec: round2((Date.now() - startMs) / 1000), rssMb });
+    readMetricsTail();
+    emit({ t: 'sample', tSec: round2((Date.now() - startMs) / 1000), rssMb, metricsLines: metricsLinesSeen });
+    if (durationSec > 0 && (Date.now() - startMs) / 1000 >= durationSec) { stopReason = 'duration'; break; }
+    // sleep in small slices so SIGINT is responsive
+    const until = Date.now() + intervalSec * 1000;
+    while (!stopping && Date.now() < until) await sleep(200);
+  }
+  readMetricsTail();
+  finalize();
+}
+
+main().catch((err) => {
+  process.stderr.write(`[collector] FATAL: ${err && err.stack ? err.stack : err}\n`);
+  process.exitCode = 1;
+});
diff --git a/scripts/scale-validate/drift-tenants.mjs b/scripts/scale-validate/drift-tenants.mjs
new file mode 100644
index 0000000000..afbed2370b
--- /dev/null
+++ b/scripts/scale-validate/drift-tenants.mjs
@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Apply deliberate shape drift to seeded tenants so the fleet spans multiple
+ * blueprints (the pooling shape-fingerprint hashes [logical schema, relname]
+ * pairs — only ADDING A RELATION changes a tenant's blueprint).
+ *
+ * Modes:
+ *   --groups K --per-group N   assign K drift groups; group g (1-based) gets a
+ *                              marker TABLE drift_marker_g<g> in app-public →
+ *                              K distinct blueprints (group 0 = undrifted).
+ *   --column-drift N           additionally give N tenants a benign EXTRA COLUMN
+ *                              on categories (same relname set → SAME blueprint;
+ *                              exercises the documented fingerprint limitation).
+ *
+ * Writes drifted.json describing the assignment. Idempotent (IF NOT EXISTS).
+ * Usage: node scripts/scale-validate/drift-tenants.mjs --groups 6 --per-group 4 --column-drift 2
+ */
+import { writeFileSync } from 'node:fs';
+
+import { resolvePg } from './_lib.mjs';
+
+const { Pool } = resolvePg();
+
+const arg = (name, dflt) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > -1 ? process.argv[i + 1] : dflt;
+};
+const GROUPS = parseInt(arg('groups', '0'), 10);
+const PER_GROUP = parseInt(arg('per-group', '4'), 10);
+const COLUMN_DRIFT = parseInt(arg('column-drift', '0'), 10);
+
+const pool = new Pool({
+  host: process.env.PGHOST || 'localhost',
+  port: parseInt(process.env.PGPORT || '5433', 10),
+  user: process.env.PGUSER || 'postgres',
+  password: process.env.PGPASSWORD || 'password',
+  database: process.env.PGDATABASE || 'constructive'
+});
+
+const main = async () => {
+  // Tenant app-public schemas, oldest first for stable assignment.
+  const { rows } = await pool.query(`
+    SELECT db.name AS dbname, s.schema_name
+    FROM metaschema_public.database db
+    JOIN metaschema_public.schema s ON s.database_id = db.id
+    WHERE db.name NOT IN ('constructive') AND s.schema_name LIKE '%-app-public'
+    ORDER BY db.name`);
+
+  const assignment = { groups: {}, columnDrift: [] };
+  let idx = 0;
+
+  for (let g = 1; g <= GROUPS; g++) {
+    assignment.groups[g] = [];
+    for (let n = 0; n < PER_GROUP && idx < rows.length; n++, idx++) {
+      const { dbname, schema_name } = rows[idx];
+      await pool.query(
+        `CREATE TABLE IF NOT EXISTS "${schema_name.replace(/"/g, '""')}"."drift_marker_g${g}" (id serial PRIMARY KEY, note text)`
+      );
+      assignment.groups[g].push(dbname);
+      console.log(`table-drift g${g}: ${dbname}`);
+    }
+  }
+
+  for (let n = 0; n < COLUMN_DRIFT && idx < rows.length; n++, idx++) {
+    const { dbname, schema_name } = rows[idx];
+    await pool.query(
+      `ALTER TABLE "${schema_name.replace(/"/g, '""')}".categories ADD COLUMN IF NOT EXISTS drift_col_only text`
+    );
+    assignment.columnDrift.push(dbname);
+    console.log(`column-drift (same blueprint, documents fingerprint limit): ${dbname}`);
+  }
+
+  writeFileSync(new URL('./drifted.json', import.meta.url), JSON.stringify(assignment, null, 2));
+  console.log(`done: ${GROUPS} table-drift groups × ${PER_GROUP}, ${COLUMN_DRIFT} column-drift; assignment → drifted.json`);
+  await pool.end();
+};
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
diff --git a/scripts/scale-validate/drop-tenants.mjs b/scripts/scale-validate/drop-tenants.mjs
new file mode 100644
index 0000000000..b4fb1880e3
--- /dev/null
+++ b/scripts/scale-validate/drop-tenants.mjs
@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// =============================================================================
+// drop-tenants.mjs — tear down factory tenants above --keep (catalog-wall
+// remediation: the rig's PG cannot introspect a 100+-tenant catalog, so the
+// fleet is trimmed to a size the VM can serve).
+//
+// Per tenant, in one transaction:
+//   1. capture its physical schema names from metaschema_public.schema
+//   2. DELETE FROM metaschema_public.database (all control-plane FKs CASCADE;
+//      metaschema delete triggers may drop physical objects as they go —
+//      requires the constructive.allow_super_constructive GUC)
+//   3. DROP SCHEMA IF EXISTS ... CASCADE for any physical schema that survived
+// Then VACUUM ANALYZE the hot catalogs and report the new catalog size.
+//
+// Usage:
+//   node scripts/scale-validate/drop-tenants.mjs --prefix factory --keep 40 [--dry-run] [--only factory101]
+// Env: PGHOST PGPORT PGUSER PGPASSWORD PGDATABASE (defaults :5433 constructive)
+// =============================================================================
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKTREE = path.resolve(__dirname, '..', '..');
+const rootRequire = createRequire(path.join(WORKTREE, 'graphql', 'query', 'package.json'));
+const requireDpAdaptor = createRequire(rootRequire.resolve('postgraphile/adaptors/pg'));
+const requireDataplan = createRequire(requireDpAdaptor.resolve('@dataplan/pg'));
+const { Pool } = requireDataplan('pg');
+
+const arg = (name, dflt) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > -1 ? process.argv[i + 1] : dflt;
+};
+const has = (name) => process.argv.includes(`--${name}`);
+
+const PREFIX = arg('prefix', 'factory');
+const KEEP = parseInt(arg('keep', '40'), 10);
+const ONLY = arg('only', null);
+const DRY = has('dry-run');
+
+const pool = new Pool({
+  host: process.env.PGHOST || 'localhost',
+  port: parseInt(process.env.PGPORT || '5433', 10),
+  user: process.env.PGUSER || 'postgres',
+  password: process.env.PGPASSWORD || 'password',
+  database: process.env.PGDATABASE || 'constructive',
+  max: 2
+});
+pool.on('error', (e) => console.error(`[pool] idle client error (continuing): ${e.message}`));
+
+const qid = (s) => `"${s.replace(/"/g, '""')}"`;
+
+async function dropOne(row) {
+  const client = await pool.connect();
+  const t0 = Date.now();
+  try {
+    await client.query('BEGIN');
+    await client.query('SET LOCAL statement_timeout = 0');
+    await client.query('SET LOCAL lock_timeout = 0');
+    await client.query(`SET LOCAL constructive.allow_super_constructive = 'true'`);
+
+    const schemas = (
+      await client.query(`SELECT schema_name FROM metaschema_public.schema WHERE database_id=$1`, [row.id])
+    ).rows.map((r) => r.schema_name);
+
+    await client.query(`DELETE FROM metaschema_public.database WHERE id=$1`, [row.id]);
+
+    let survivors = 0;
+    for (const s of schemas) {
+      const exists = await client.query(`SELECT 1 FROM pg_namespace WHERE nspname=$1`, [s]);
+      if (exists.rows.length) {
+        survivors++;
+        await client.query(`DROP SCHEMA IF EXISTS ${qid(s)} CASCADE`);
+      }
+    }
+
+    // pg_partman registers partitioned tables by NAME in partman.part_config —
+    // not schema-scoped, not FK-cascaded — and schema hashes are deterministic
+    // per dbname, so a leftover row blocks re-provisioning a reused tenant name
+    // (unique_violation on parent_table). Clean them with the schemas.
+    if (schemas.length) {
+      const patterns = schemas.map((s) => `${s}.%`);
+      try {
+        await client.query(`DELETE FROM partman.part_config_sub WHERE sub_parent LIKE ANY($1)`, [patterns]);
+      } catch {
+        /* part_config_sub may not exist */
+      }
+      try {
+        const del = await client.query(`DELETE FROM partman.part_config WHERE parent_table LIKE ANY($1)`, [
+          patterns
+        ]);
+        if (del.rowCount) console.log(`  [${row.name}] cleaned ${del.rowCount} partman.part_config row(s)`);
+      } catch {
+        /* partman may not be installed */
+      }
+    }
+
+    if (DRY) await client.query('ROLLBACK');
+    else await client.query('COMMIT');
+    console.log(
+      `  [${row.name}] dropped (schemas=${schemas.length} survivors-dropped=${survivors}) ${Date.now() - t0}ms${DRY ? ' [DRY]' : ''}`
+    );
+    return { ok: true };
+  } catch (e) {
+    try {
+      await client.query('ROLLBACK');
+    } catch {}
+    console.error(`  [${row.name}] FAILED: ${e.code || ''} ${e.message}`);
+    return { ok: false, error: e.message };
+  } finally {
+    client.release();
+  }
+}
+
+const main = async () => {
+  const where = ONLY
+    ? { sql: `name = $1`, params: [ONLY] }
+    : {
+        sql: `name ~ ('^' || $1 || '[0-9]+$') AND (regexp_replace(name, '^' || $1, ''))::int > $2`,
+        params: [PREFIX, KEEP]
+      };
+  const { rows } = await pool.query(
+    `SELECT id, name FROM metaschema_public.database WHERE ${where.sql}
+     ORDER BY (regexp_replace(name, '[^0-9]', '', 'g'))::int NULLS LAST`,
+    where.params
+  );
+  console.log(`drop-tenants: ${rows.length} tenant(s) to drop${DRY ? ' [DRY-RUN]' : ''}`);
+
+  let ok = 0;
+  for (const row of rows) {
+    const r = await dropOne(row);
+    if (r.ok) ok++;
+  }
+  console.log(`dropped ${ok}/${rows.length}`);
+
+  if (!DRY && ok > 0) {
+    console.log('VACUUM ANALYZE hot catalogs...');
+    for (const cat of ['pg_class', 'pg_attribute', 'pg_proc', 'pg_constraint', 'pg_policy', 'pg_namespace', 'pg_depend', 'pg_type']) {
+      await pool.query(`VACUUM ANALYZE ${cat}`);
+    }
+  }
+
+  const stats = await pool.query(`
+    SELECT (SELECT count(*) FROM pg_class) AS classes,
+           (SELECT count(*) FROM pg_attribute) AS attrs,
+           (SELECT count(*) FROM pg_namespace) AS namespaces,
+           (SELECT count(*) FROM metaschema_public.database) AS databases`);
+  console.log(`catalog now: ${JSON.stringify(stats.rows[0])}`);
+  await pool.end();
+};
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
diff --git a/scripts/scale-validate/fleet.mjs b/scripts/scale-validate/fleet.mjs
new file mode 100644
index 0000000000..4c89f0ba43
--- /dev/null
+++ b/scripts/scale-validate/fleet.mjs
@@ -0,0 +1,107 @@
+/**
+ * fleet.mjs — print a JSON fleet manifest describing every marketplace tenant.
+ *
+ * For each tenant database (metaschema_public.database where name like the
+ * --like pattern) it resolves:
+ *   - databaseId
+ *   - api host  (services_public.domains subdomain like 'api-%'  + '.' + domain)
+ *   - auth host (services_public.domains subdomain like 'auth-%' + '.' + domain)
+ *   - the physical schemas of the `api` API
+ *       (services_public.apis JOIN api_schemas JOIN metaschema_public.schema)
+ *
+ * Usage:
+ *   node scripts/scale-validate/fleet.mjs > fleet.json
+ *   node scripts/scale-validate/fleet.mjs --like 'marketplace%' --pretty
+ *   PGPORT=5433 node scripts/scale-validate/fleet.mjs --out fleet.json
+ */
+import fs from 'node:fs';
+import { asBool, nowIso, parseArgs, pgConfigFromArgs, resolvePg } from './_lib.mjs';
+
+const HELP = `fleet.mjs — emit JSON fleet manifest from the control-plane DB
+
+Options:
+  --like <pattern>   database name filter (default: 'marketplace%')
+  --out <file>       write JSON here instead of stdout
+  --pretty           pretty-print JSON
+  --pg-host/--pg-port/--pg-user/--pg-password/--pg-database  connection overrides
+  --help
+`;
+
+const FLEET_SQL = `
+SELECT
+  d.name AS dbname,
+  d.id::text AS database_id,
+  (SELECT dom.subdomain || '.' || dom.domain
+     FROM services_public.domains dom
+     WHERE dom.database_id = d.id AND dom.subdomain LIKE 'api-%'
+     ORDER BY dom.subdomain LIMIT 1) AS api_host,
+  (SELECT dom.subdomain || '.' || dom.domain
+     FROM services_public.domains dom
+     WHERE dom.database_id = d.id AND dom.subdomain LIKE 'auth-%'
+     ORDER BY dom.subdomain LIMIT 1) AS auth_host,
+  COALESCE((
+    SELECT array_agg(s.schema_name ORDER BY s.schema_name)
+      FROM services_public.apis a
+      JOIN services_public.api_schemas aps ON aps.api_id = a.id AND aps.database_id = a.database_id
+      JOIN metaschema_public.schema s ON s.id = aps.schema_id
+     WHERE a.database_id = d.id AND a.name = 'api'
+  ), ARRAY[]::text[]) AS schemas
+FROM metaschema_public.database d
+WHERE d.name LIKE $1
+ORDER BY d.name;
+`;
+
+async function main() {
+  const { args } = parseArgs(process.argv.slice(2));
+  if (asBool(args.help)) {
+    process.stdout.write(HELP);
+    return;
+  }
+  const like = typeof args.like === 'string' ? args.like : 'marketplace%';
+  const pretty = asBool(args.pretty);
+  const cfg = pgConfigFromArgs(args);
+  const { Client } = resolvePg();
+  const client = new Client(cfg);
+  await client.connect();
+  let rows;
+  try {
+    const res = await client.query(FLEET_SQL, [like]);
+    rows = res.rows;
+  } finally {
+    await client.end();
+  }
+
+  const tenants = rows.map((r) => {
+    const schemas = r.schemas || [];
+    const appPublicSchema = schemas.find((s) => /-app-public$/.test(s)) || schemas[0] || null;
+    return {
+      dbname: r.dbname,
+      databaseId: r.database_id,
+      apiHost: r.api_host,
+      authHost: r.auth_host,
+      schemas,
+      appPublicSchema
+    };
+  });
+
+  const manifest = {
+    generatedAt: nowIso(),
+    like,
+    pg: { host: cfg.host, port: cfg.port, database: cfg.database },
+    count: tenants.length,
+    tenants
+  };
+
+  const json = JSON.stringify(manifest, null, pretty ? 2 : 0);
+  if (typeof args.out === 'string') {
+    fs.writeFileSync(args.out, `${json}\n`, 'utf8');
+    process.stderr.write(`[fleet] wrote ${tenants.length} tenants to ${args.out}\n`);
+  } else {
+    process.stdout.write(`${json}\n`);
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`[fleet] ERROR: ${err && err.stack ? err.stack : err}\n`);
+  process.exitCode = 1;
+});
diff --git a/scripts/scale-validate/harness.mjs b/scripts/scale-validate/harness.mjs
new file mode 100644
index 0000000000..e98349bccf
--- /dev/null
+++ b/scripts/scale-validate/harness.mjs
@@ -0,0 +1,694 @@
+/**
+ * harness.mjs — workload driver for the scale validation soak/ramp.
+ *
+ * Generates a token-bucket-paced request stream (open-loop) at a target RPS
+ * across the tenant fleet, with a read/write/meta class mix, tenant-selection
+ * shapes (zipf/uniform/burst), per-tenant auth, a cross-tenant bleed sentinel,
+ * latency histograms, rolling per-minute stdout summaries, and a final JSON
+ * report.
+ *
+ * NO server/package code is imported — this only speaks GraphQL over HTTP.
+ *
+ * Usage:
+ *   node scripts/scale-validate/harness.mjs --help
+ *   node scripts/scale-validate/harness.mjs --fleet fleet.json --port 3333 \
+ *     --duration-sec 600 --rps 40 --mix read:0.7,write:0.25,meta:0.05 \
+ *     --shape zipf --auth 1 --sentinel-interval-sec 60 --out results.json
+ *
+ * Exit codes: 0 ok, 1 fatal error, 2 bleed-sentinel violation.
+ */
+import fs from 'node:fs';
+import {
+  Histogram, INTROSPECTION_QUERY, asBool, asFloat, asInt, buildCreateRecord, buildTypeIndex,
+  canaryName, CANARY_PREFIX, discoverOps, gqlErrors, gqlFetch, isRotating, isUnauthenticated,
+  loadFleet, makeMixSampler, makeRng, makeZipfSampler, nowIso, parseArgs, round2, sleep, unwrapType
+} from './_lib.mjs';
+
+const HELP = `harness.mjs — workload driver (soaks + ramps) against the running cnc server
+
+Required:
+  --fleet <file>              fleet manifest from fleet.mjs
+Common:
+  --port <n>                  server port (default 3333)
+  --duration-sec <n>          run length (default 60)
+  --rps <n>                   target requests/sec (default 20)
+  --mix read:.7,write:.25,meta:.05   class mix (default that)
+  --shape zipf|uniform|burst  tenant selection (default zipf)
+  --auth 0|1                  authenticate reads/writes (default 1)
+  --sentinel-interval-sec <n> bleed sentinel period (default 60)
+  --out <file>                final JSON report (default results.json)
+Tuning:
+  --report-sec <n>            rolling summary interval (default 60)
+  --burst-window-sec <n>      burst shape focus window (default 30)
+  --relogin-sec <n>           token refresh period (default 3600)
+  --timeout-ms <n>            per-request timeout (default 30000)
+  --max-inflight <n>          concurrency cap (default max(64, rps*2))
+  --rotate-backoff-ms <n>     503 retry backoff (default 250)
+  --email / --password        seeder credentials (defaults provided)
+  --seed <n>                  RNG seed for reproducible selection
+  --quiet                     suppress per-minute lines (still written to --out)
+  --help
+
+Leaked LOAD- rows (only on delete failure) are reported as write.leaked; clean
+with: DELETE FROM "<schema>".categories WHERE name LIKE 'LOAD-%';
+`;
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const { args } = parseArgs(process.argv.slice(2));
+if (asBool(args.help) || !args.fleet) {
+  process.stdout.write(HELP);
+  if (!args.fleet && !asBool(args.help)) process.exitCode = 1;
+  process.exit();
+}
+
+const PORT = asInt(args.port, 3333);
+const DURATION_SEC = asInt(args['duration-sec'], 60);
+const RPS = Math.max(asFloat(args.rps, 20), 0.1);
+const MIX = typeof args.mix === 'string' ? args.mix : 'read:0.7,write:0.25,meta:0.05';
+const SHAPE = ['zipf', 'uniform', 'burst'].includes(args.shape) ? args.shape : 'zipf';
+const AUTH = asBool(args.auth, true);
+const SENTINEL_SEC = asInt(args['sentinel-interval-sec'], 60);
+const OUT = typeof args.out === 'string' ? args.out : 'results.json';
+const REPORT_SEC = asInt(args['report-sec'], 60);
+const BURST_WINDOW_SEC = asInt(args['burst-window-sec'], 30);
+const RELOGIN_SEC = asInt(args['relogin-sec'], 3600);
+const TIMEOUT_MS = asInt(args['timeout-ms'], 30000);
+const MAX_INFLIGHT = asInt(args['max-inflight'], Math.max(64, Math.ceil(RPS * 2)));
+const ROTATE_BACKOFF_MS = asInt(args['rotate-backoff-ms'], 250);
+const EMAIL = typeof args.email === 'string' ? args.email : 'seeder@gmail.com';
+// Never a literal default: flag > PERF_PASSWORD env (matches packages/perf-harness resolveCreds).
+const PASSWORD = typeof args.password === 'string' ? args.password : (process.env.PERF_PASSWORD ?? null);
+if (AUTH && !PASSWORD) {
+  console.error('[harness] --auth requires credentials: pass --password or set PERF_PASSWORD');
+  // Exit 3 = config error. Exit 2 is reserved exclusively for the bleed sentinel
+  // (cross-tenant isolation violation) — suites key on it; never reuse it.
+  process.exit(3);
+}
+const SEED = asInt(args.seed, (Date.now() & 0x7fffffff));
+const QUIET = asBool(args.quiet);
+
+const rng = makeRng(SEED);
+const { tenants } = loadFleet(args.fleet);
+
+// ---------------------------------------------------------------------------
+// Metrics
+// ---------------------------------------------------------------------------
+const M = {
+  startedAt: nowIso(),
+  config: {
+    port: PORT, durationSec: DURATION_SEC, rps: RPS, mix: MIX, shape: SHAPE, auth: AUTH,
+    sentinelIntervalSec: SENTINEL_SEC, reportSec: REPORT_SEC, burstWindowSec: BURST_WINDOW_SEC,
+    reloginSec: RELOGIN_SEC, timeoutMs: TIMEOUT_MS, maxInflight: MAX_INFLIGHT, seed: SEED,
+    fleetCount: tenants.length
+  },
+  totals: { sent: 0, completed: 0, ok: 0, err: 0, requests: 0, dropped: 0, rotating: 0, rotatingRetried: 0, timeouts: 0, network: 0 },
+  http: {},
+  netErrors: {},
+  gqlByCode: {},
+  gqlByMsg: {},
+  gqlMsgOverflow: 0,
+  classes: {
+    read: { sent: 0, ok: 0, err: 0, unavailable: 0, hist: new Histogram() },
+    write: { sent: 0, ok: 0, err: 0, unavailable: 0, fallbackRead: 0, created: 0, deleted: 0, leaked: 0, createErr: 0, deleteErr: 0, hist: new Histogram() },
+    meta: { sent: 0, ok: 0, err: 0, unavailable: 0, hist: new Histogram() }
+  },
+  overallHist: new Histogram(),
+  perTenant: {},
+  auth: { enabled: AUTH, shape: null, logins: 0, loginFailures: 0, relogins: 0, unauth: 0 },
+  sentinel: { checks: 0, tenantsChecked: 0, ownCanarySeen: 0, inconclusive: 0, violations: [], ok: true },
+  progress: []
+};
+for (const t of tenants) M.perTenant[t.dbname] = { sent: 0, ok: 0, err: 0 };
+
+let windowHist = new Histogram();
+const startMs = Date.now();
+let pacingStartMs = 0;
+let inFlight = 0;
+let stopping = false;
+let stopReason = null;
+
+// ---------------------------------------------------------------------------
+// Runtime tenant state
+// ---------------------------------------------------------------------------
+const runtime = tenants.map((tenant) => ({
+  tenant,
+  ops: { read: null, meta: false, create: null, del: null },
+  token: null,
+  tokenAt: 0,
+  reloginInFlight: false,
+  authError: null,
+  introspectError: null,
+  leakedKeys: []
+}));
+
+let writeCounter = 0;
+const randId = () => `${(SEED & 0xffff).toString(36)}-${(writeCounter++).toString(36)}-${Math.floor(rng() * 1e9).toString(36)}`;
+const log = (...a) => { if (!QUIET) process.stderr.write(`${a.join(' ')}\n`); };
+const emit = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
+
+// ---------------------------------------------------------------------------
+// HTTP request with retry-once on 503 SERVICE_ROTATING
+// ---------------------------------------------------------------------------
+async function apiRequest(s, { query, variables, token }) {
+  let resp = await gqlFetch({ host: s.tenant.apiHost, port: PORT, query, variables, token, timeoutMs: TIMEOUT_MS });
+  if (isRotating(resp)) {
+    M.totals.rotating++;
+    await sleep(ROTATE_BACKOFF_MS);
+    resp = await gqlFetch({ host: s.tenant.apiHost, port: PORT, query, variables, token, timeoutMs: TIMEOUT_MS });
+    M.totals.rotatingRetried++;
+  }
+  return resp;
+}
+
+function trackHttp(resp, cls) {
+  M.totals.requests++;
+  M.overallHist.record(resp.elapsedMs);
+  windowHist.record(resp.elapsedMs);
+  M.classes[cls].hist.record(resp.elapsedMs);
+  const key = String(resp.status);
+  M.http[key] = (M.http[key] || 0) + 1;
+  if (resp.error === 'timeout') M.totals.timeouts++;
+  else if (resp.error) { M.totals.network++; M.netErrors[resp.error] = (M.netErrors[resp.error] || 0) + 1; }
+  for (const e of gqlErrors(resp)) {
+    const code = (e.extensions && e.extensions.code) || 'GRAPHQL_ERROR';
+    M.gqlByCode[code] = (M.gqlByCode[code] || 0) + 1;
+    const msg = String((e && e.message) || '').slice(0, 200);
+    // Cap distinct-message cardinality so a 24h soak with id-bearing messages
+    // cannot grow this map without bound.
+    if (M.gqlByMsg[msg] !== undefined || Object.keys(M.gqlByMsg).length < 1000) {
+      M.gqlByMsg[msg] = (M.gqlByMsg[msg] || 0) + 1;
+    } else {
+      M.gqlMsgOverflow++;
+    }
+  }
+}
+
+function bumpTenant(s, kind) { const p = M.perTenant[s.tenant.dbname]; if (p) p[kind]++; }
+
+function maybeRelogin(s, resp) {
+  if (!AUTH) return;
+  if (isUnauthenticated(resp)) { M.auth.unauth++; scheduleRelogin(s); }
+}
+
+// ---------------------------------------------------------------------------
+// Op executors — each returns { ok } or { skip:true }; runOp folds into totals.
+// ---------------------------------------------------------------------------
+async function execRead(s) {
+  const r = M.classes.read;
+  r.sent++;
+  const resp = await apiRequest(s, { query: `{ ${s.ops.read} { totalCount nodes { name } } }`, token: s.token });
+  trackHttp(resp, 'read');
+  maybeRelogin(s, resp);
+  const ok = resp.ok && gqlErrors(resp).length === 0 && !resp.error;
+  if (ok) r.ok++; else r.err++;
+  bumpTenant(s, ok ? 'ok' : 'err');
+  return { ok };
+}
+
+async function execMeta(s) {
+  const m = M.classes.meta;
+  m.sent++;
+  const resp = await apiRequest(s, { query: '{ _meta { tables { name } } }' });
+  trackHttp(resp, 'meta');
+  const ok = resp.ok && gqlErrors(resp).length === 0 && !resp.error;
+  if (ok) m.ok++; else m.err++;
+  bumpTenant(s, ok ? 'ok' : 'err');
+  return { ok };
+}
+
+function createQuery(c) {
+  return `mutation Create($input: ${c.inputTypeName}!) { ${c.name}(input: $input) { ${c.payloadFieldName} { ${c.keySelect} } } }`;
+}
+function deleteQuery(d) {
+  return `mutation Del($input: ${d.inputTypeName}!) { ${d.name}(input: $input) { clientMutationId } }`;
+}
+
+async function execWrite(s) {
+  const w = M.classes.write;
+  w.sent++;
+  const rand = randId();
+  const record = buildCreateRecord(s.ops.create, `LOAD-${rand}`, rand);
+  const cResp = await apiRequest(s, {
+    query: createQuery(s.ops.create),
+    variables: { input: { [s.ops.create.innerName]: record } },
+    token: s.token
+  });
+  trackHttp(cResp, 'write');
+  maybeRelogin(s, cResp);
+  const cOk = cResp.ok && gqlErrors(cResp).length === 0 && !cResp.error;
+  if (!cOk) { w.createErr++; w.err++; bumpTenant(s, 'err'); return { ok: false }; }
+  w.created++;
+  const payload = cResp.json && cResp.json.data && cResp.json.data[s.ops.create.name];
+  const rec = payload && payload[s.ops.create.payloadFieldName];
+  const keyVal = rec && rec[s.ops.create.keySelect];
+  if (keyVal == null) { w.err++; w.leaked++; bumpTenant(s, 'err'); return { ok: false }; }
+  const dResp = await apiRequest(s, {
+    query: deleteQuery(s.ops.del),
+    variables: { input: { [s.ops.del.key]: keyVal } },
+    token: s.token
+  });
+  trackHttp(dResp, 'write');
+  maybeRelogin(s, dResp);
+  const dOk = dResp.ok && gqlErrors(dResp).length === 0 && !dResp.error;
+  if (dOk) { w.deleted++; w.ok++; bumpTenant(s, 'ok'); return { ok: true }; }
+  w.deleteErr++; w.leaked++; w.err++;
+  if (s.leakedKeys.length < 200) s.leakedKeys.push(keyVal);
+  bumpTenant(s, 'err');
+  return { ok: false };
+}
+
+// Substitution keeps a tenant's PostGraphile instance under load even when a
+// class is unavailable for it (e.g. the blank tenant with no categories table).
+function canWrite(s) { return !!(s.ops.create && s.ops.del && s.ops.create.payloadFieldName); }
+
+async function opRead(s) {
+  if (s.ops.read) return execRead(s);
+  M.classes.read.unavailable++;
+  if (s.ops.meta) return execMeta(s);
+  return { skip: true };
+}
+async function opMeta(s) {
+  if (s.ops.meta) return execMeta(s);
+  M.classes.meta.unavailable++;
+  if (s.ops.read) return execRead(s);
+  return { skip: true };
+}
+async function opWrite(s) {
+  if (canWrite(s)) return execWrite(s);
+  M.classes.write.unavailable++;
+  if (s.ops.read) { M.classes.write.fallbackRead++; return execRead(s); }
+  if (s.ops.meta) { M.classes.write.fallbackRead++; return execMeta(s); }
+  return { skip: true };
+}
+
+async function runOp(cls, s) {
+  M.perTenant[s.tenant.dbname].sent++;
+  let res;
+  if (cls === 'read') res = await opRead(s);
+  else if (cls === 'write') res = await opWrite(s);
+  else res = await opMeta(s);
+  if (res && res.skip) return;
+  if (res && res.ok) M.totals.ok++; else M.totals.err++;
+}
+
+// ---------------------------------------------------------------------------
+// Auth
+// ---------------------------------------------------------------------------
+function scoreTokenField(name) {
+  if (/^accesstoken$/i.test(name)) return 4;
+  if (/accesstoken/i.test(name)) return 3;
+  if (/token/i.test(name)) return 2;
+  if (/jwt/i.test(name)) return 1;
+  return 0;
+}
+function findTokenSelection(index, payloadTypeName) {
+  const pt = index.get(payloadTypeName);
+  if (!pt) return null;
+  let best = null;
+  const consider = (selection, path, score) => { if (score > 0 && (!best || score > best.score)) best = { selection, path, score }; };
+  for (const f of (pt.fields || [])) {
+    const nt = index.get(unwrapType(f.type).name);
+    if (nt && nt.kind === 'SCALAR') consider(f.name, [f.name], scoreTokenField(f.name));
+  }
+  if (best && best.score >= 3) return best;
+  for (const f of (pt.fields || [])) {
+    const nt = index.get(unwrapType(f.type).name);
+    if (nt && nt.kind === 'OBJECT') {
+      for (const sf of (nt.fields || [])) {
+        const st = index.get(unwrapType(sf.type).name);
+        if (st && st.kind === 'SCALAR') consider(`${f.name} { ${sf.name} }`, [f.name, sf.name], scoreTokenField(sf.name));
+      }
+    }
+  }
+  return best;
+}
+
+const getByPath = (obj, path) => {
+  let cur = obj;
+  for (const k of path) { if (cur == null) return null; cur = cur[k]; }
+  return cur == null ? null : cur;
+};
+
+async function resolveAuthShape() {
+  for (const s of runtime) {
+    if (!s.tenant.authHost) continue;
+    const resp = await gqlFetch({ host: s.tenant.authHost, port: PORT, query: INTROSPECTION_QUERY, timeoutMs: TIMEOUT_MS });
+    const data = resp.json && resp.json.data;
+    if (!data || !data.__schema) continue;
+    const { index, mutationType } = buildTypeIndex(data);
+    if (!mutationType) continue;
+    const mt = index.get(mutationType);
+    const field = (mt.fields || []).find((f) => /^signin$/i.test(f.name)) || (mt.fields || []).find((f) => /signin/i.test(f.name));
+    if (!field) continue;
+    const tokenSel = findTokenSelection(index, unwrapType(field.type).name);
+    if (!tokenSel) continue;
+    const query = `mutation SignIn($email: String!, $password: String!) { ${field.name}(input: { email: $email, password: $password }) { ${tokenSel.selection} } }`;
+    return { field: field.name, query, path: [field.name, ...tokenSel.path], selection: tokenSel.selection };
+  }
+  // Fallback: documented shape.
+  return {
+    field: 'signIn',
+    query: 'mutation SignIn($email: String!, $password: String!) { signIn(input: { email: $email, password: $password }) { result { accessToken } } }',
+    path: ['signIn', 'result', 'accessToken'],
+    selection: 'result { accessToken }'
+  };
+}
+
+let authShape = null;
+async function loginTenant(s, initial) {
+  if (!authShape || !s.tenant.authHost) return false;
+  const resp = await gqlFetch({ host: s.tenant.authHost, port: PORT, query: authShape.query, variables: { email: EMAIL, password: PASSWORD }, timeoutMs: TIMEOUT_MS });
+  const errs = gqlErrors(resp);
+  if (!resp.ok || errs.length || resp.error) {
+    M.auth.loginFailures++;
+    s.authError = (errs[0] && errs[0].message) || resp.error || `http ${resp.status}`;
+    return false;
+  }
+  const tok = getByPath(resp.json && resp.json.data, authShape.path);
+  if (!tok || typeof tok !== 'string') { M.auth.loginFailures++; s.authError = 'no token in signIn response'; return false; }
+  s.token = tok;
+  s.tokenAt = Date.now();
+  s.authError = null;
+  if (initial) M.auth.logins++; else M.auth.relogins++;
+  return true;
+}
+
+function scheduleRelogin(s) {
+  if (s.reloginInFlight) return;
+  s.reloginInFlight = true;
+  loginTenant(s, false).catch(() => {}).finally(() => { s.reloginInFlight = false; });
+}
+
+// ---------------------------------------------------------------------------
+// Startup capability discovery (introspection + probe verification)
+// ---------------------------------------------------------------------------
+const DEFAULT_OPS = () => ({
+  read: 'categories',
+  meta: true,
+  create: { name: 'createCategory', inputTypeName: 'CreateCategoryInput', innerName: 'category', requiredScalars: [{ name: 'name', scalar: 'String', kind: 'SCALAR' }, { name: 'slug', scalar: 'String', kind: 'SCALAR' }], payloadFieldName: 'category', keySelect: 'id' },
+  del: { name: 'deleteCategory', inputTypeName: 'DeleteCategoryInput', key: 'id' }
+});
+
+const isValidationAbsent = (resp) => gqlErrors(resp).some((e) => /cannot query field|unknown field|unknown argument|unknown type|does not exist on type|not defined|no field/i.test((e && e.message) || ''));
+
+async function resolveTenantOps(s) {
+  const resp = await apiRequest(s, { query: INTROSPECTION_QUERY });
+  const data = resp.json && resp.json.data;
+  if (data && data.__schema) {
+    s.ops = discoverOps(data);
+  } else {
+    s.introspectError = (gqlErrors(resp)[0] && gqlErrors(resp)[0].message) || resp.error || `http ${resp.status}`;
+    s.ops = DEFAULT_OPS();
+  }
+  // Probe read presence (schema-level) with token so RLS doesn't mask absence.
+  if (s.ops.read) {
+    const pr = await apiRequest(s, { query: `{ ${s.ops.read} { totalCount } }`, token: s.token });
+    if (isValidationAbsent(pr)) s.ops.read = null;
+  }
+  if (s.ops.meta) {
+    const pm = await apiRequest(s, { query: '{ _meta { tables { name } } }' });
+    if (isValidationAbsent(pm)) s.ops.meta = false;
+  }
+  // Probe write: attempt a real create+delete once; downgrade only on schema absence.
+  if (canWrite(s)) {
+    const rand = `probe-${randId()}`;
+    const record = buildCreateRecord(s.ops.create, `LOAD-${rand}`, rand);
+    const cr = await apiRequest(s, { query: createQuery(s.ops.create), variables: { input: { [s.ops.create.innerName]: record } }, token: s.token });
+    if (isValidationAbsent(cr)) {
+      s.ops.create = null;
+      s.ops.del = null;
+    } else {
+      const payload = cr.json && cr.json.data && cr.json.data[s.ops.create.name];
+      const rec = payload && payload[s.ops.create.payloadFieldName];
+      const keyVal = rec && rec[s.ops.create.keySelect];
+      if (keyVal != null) {
+        await apiRequest(s, { query: deleteQuery(s.ops.del), variables: { input: { [s.ops.del.key]: keyVal } }, token: s.token });
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Bleed sentinel
+// ---------------------------------------------------------------------------
+function pickTwo(arr) {
+  if (arr.length <= 1) return arr.slice();
+  const i = Math.floor(rng() * arr.length);
+  let j = Math.floor(rng() * arr.length);
+  if (j === i) j = (j + 1) % arr.length;
+  return [arr[i], arr[j]];
+}
+
+async function runSentinel() {
+  if (stopping) return;
+  M.sentinel.checks++;
+  const eligible = runtime.filter((s) => s.ops.read && (!AUTH || s.token));
+  if (eligible.length === 0) { M.sentinel.inconclusive++; return; }
+  const picks = pickTwo(eligible);
+  for (const s of picks) {
+    M.sentinel.tenantsChecked++;
+    const resp = await apiRequest(s, { query: `{ ${s.ops.read} { nodes { name } } }`, token: s.token });
+    if (!resp.ok || gqlErrors(resp).length || resp.error) { M.sentinel.inconclusive++; continue; }
+    const nodes = (((resp.json || {}).data || {})[s.ops.read] || {}).nodes || [];
+    const own = canaryName(s.tenant);
+    let sawOwn = false;
+    for (const node of nodes) {
+      const nm = node && node.name;
+      if (typeof nm !== 'string') continue;
+      if (nm === own) { sawOwn = true; continue; }
+      if (nm.startsWith(CANARY_PREFIX)) {
+        M.sentinel.ok = false;
+        M.sentinel.violations.push({
+          at: nowIso(),
+          readTenant: s.tenant.dbname,
+          readHost: s.tenant.apiHost,
+          foreignCanary: nm,
+          sampleNames: nodes.map((n) => n && n.name).filter(Boolean).slice(0, 50)
+        });
+      }
+    }
+    if (sawOwn) M.sentinel.ownCanarySeen++;
+  }
+  if (!M.sentinel.ok) {
+    process.exitCode = 2;
+    finish('sentinel-violation');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Pacer (token bucket) + worker pool
+// ---------------------------------------------------------------------------
+const zipfSampler = SHAPE === 'zipf' ? makeZipfSampler(runtime.length, rng) : null;
+let burstIndex = Math.floor(rng() * runtime.length);
+let burstUntil = Date.now() + BURST_WINDOW_SEC * 1000;
+
+function pickTenant() {
+  if (SHAPE === 'uniform') return runtime[Math.floor(rng() * runtime.length)];
+  if (SHAPE === 'burst') {
+    if (Date.now() >= burstUntil) {
+      burstIndex = Math.floor(rng() * runtime.length);
+      burstUntil = Date.now() + BURST_WINDOW_SEC * 1000;
+    }
+    return runtime[burstIndex];
+  }
+  return runtime[zipfSampler()];
+}
+
+const mixSampler = makeMixSampler(MIX, rng);
+
+let tokens = 0;
+const capacity = Math.max(RPS, 1);
+const tickMs = 20;
+const refillPerTick = RPS * (tickMs / 1000);
+
+function launchOne() {
+  inFlight++;
+  M.totals.sent++;
+  const s = pickTenant();
+  const cls = mixSampler();
+  runOp(cls, s).catch(() => {}).finally(() => {
+    inFlight--;
+    M.totals.completed++;
+    pump();
+  });
+}
+
+function pump() {
+  while (!stopping && tokens >= 1 && inFlight < MAX_INFLIGHT) {
+    tokens -= 1;
+    launchOne();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Rolling per-interval reporter
+// ---------------------------------------------------------------------------
+let snap = { t: startMs, completed: 0, ok: 0, err: 0 };
+function report(kind) {
+  const nowT = Date.now();
+  const elapsedSec = (nowT - startMs) / 1000;
+  const winSec = Math.max((nowT - snap.t) / 1000, 0.001);
+  const dc = M.totals.completed - snap.completed;
+  const der = M.totals.err - snap.err;
+  const line = {
+    t: kind,
+    at: nowIso(),
+    elapsedSec: round2(elapsedSec),
+    windowSec: round2(winSec),
+    sent: M.totals.sent,
+    completed: M.totals.completed,
+    ok: M.totals.ok,
+    err: M.totals.err,
+    windowRps: round2(dc / winSec),
+    cumRps: round2(M.totals.completed / Math.max(elapsedSec, 0.001)),
+    windowErrRate: dc ? round2(der / dc) : 0,
+    inFlight,
+    dropped: Math.round(M.totals.dropped),
+    rotating: M.totals.rotating,
+    latencyWindow: windowHist.summary(),
+    sentinelChecks: M.sentinel.checks,
+    sentinelOwnSeen: M.sentinel.ownCanarySeen,
+    sentinelOk: M.sentinel.ok
+  };
+  emit(line);
+  M.progress.push(line);
+  snap = { t: nowT, completed: M.totals.completed, ok: M.totals.ok, err: M.totals.err };
+  windowHist = new Histogram();
+}
+
+// ---------------------------------------------------------------------------
+// Lifecycle
+// ---------------------------------------------------------------------------
+let timers = [];
+let durationTimer = null;
+let donePromiseResolve;
+const donePromise = new Promise((res) => { donePromiseResolve = res; });
+
+function finish(reason) {
+  if (stopping) return;
+  stopping = true;
+  stopReason = reason;
+  for (const t of timers) clearInterval(t);
+  timers = [];
+  if (durationTimer) { clearTimeout(durationTimer); durationTimer = null; }
+  donePromiseResolve();
+}
+
+async function drain() {
+  const deadline = Date.now() + 15000;
+  while (inFlight > 0 && Date.now() < deadline) await sleep(50);
+}
+
+function finalize() {
+  const endMs = Date.now();
+  const wallSec = (endMs - startMs) / 1000;
+  const loadSec = (endMs - (pacingStartMs || startMs)) / 1000;
+  const topN = (obj, n = 20) => Object.entries(obj).sort((a, b) => b[1] - a[1]).slice(0, n).map(([k, v]) => ({ key: k, count: v }));
+  const classSummary = (c) => {
+    const base = { sent: c.sent, ok: c.ok, err: c.err, unavailable: c.unavailable, latency: c.hist.summary() };
+    if (c === M.classes.write) {
+      return { ...base, created: c.created, deleted: c.deleted, leaked: c.leaked, createErr: c.createErr, deleteErr: c.deleteErr, fallbackRead: c.fallbackRead };
+    }
+    return base;
+  };
+  const out = {
+    startedAt: M.startedAt,
+    endedAt: nowIso(),
+    wallSec: round2(wallSec),
+    loadSec: round2(loadSec),
+    stopReason,
+    config: M.config,
+    fleet: { count: tenants.length, file: args.fleet },
+    capabilities: runtime.map((s) => ({
+      dbname: s.tenant.dbname,
+      apiHost: s.tenant.apiHost,
+      read: !!s.ops.read,
+      write: canWrite(s),
+      meta: !!s.ops.meta,
+      authed: !!s.token,
+      authError: s.authError,
+      introspectError: s.introspectError,
+      leakedKeys: s.leakedKeys.length
+    })),
+    totals: {
+      ...M.totals,
+      dropped: Math.round(M.totals.dropped),
+      achievedRps: round2(M.totals.completed / Math.max(loadSec, 0.001)),
+      errRate: M.totals.completed ? round2(M.totals.err / M.totals.completed) : 0
+    },
+    latencyOverall: M.overallHist.summary(),
+    byClass: { read: classSummary(M.classes.read), write: classSummary(M.classes.write), meta: classSummary(M.classes.meta) },
+    http: M.http,
+    netErrors: M.netErrors,
+    gqlErrorsByCode: M.gqlByCode,
+    gqlErrorsTop: topN(M.gqlByMsg),
+    gqlErrorsMsgOverflow: M.gqlMsgOverflow,
+    perTenant: M.perTenant,
+    auth: M.auth,
+    sentinel: M.sentinel,
+    progress: M.progress,
+    verdict: {
+      pass: M.sentinel.ok,
+      bleedViolations: M.sentinel.violations.length,
+      note: M.sentinel.ok ? 'no cross-tenant bleed detected' : 'BLEED SENTINEL VIOLATION'
+    }
+  };
+  fs.writeFileSync(OUT, `${JSON.stringify(out, null, 2)}\n`);
+  return out;
+}
+
+async function main() {
+  log(`[harness] seed=${SEED} shape=${SHAPE} rps=${RPS} dur=${DURATION_SEC}s mix=${MIX} auth=${AUTH} tenants=${tenants.length} -> ${OUT}`);
+
+  if (AUTH) {
+    authShape = await resolveAuthShape();
+    M.auth.shape = authShape.selection;
+    log(`[harness] auth shape: ${authShape.field} { ${authShape.selection} }`);
+    await Promise.all(runtime.map((s) => loginTenant(s, true)));
+    log(`[harness] logins ok=${M.auth.logins} failed=${M.auth.loginFailures}`);
+  }
+
+  await Promise.all(runtime.map((s) => resolveTenantOps(s).catch((e) => { s.introspectError = String(e && e.message || e); })));
+  const caps = runtime.map((s) => `${s.tenant.dbname.replace('marketplace_db_', '')}[r=${s.ops.read ? 1 : 0}w=${canWrite(s) ? 1 : 0}m=${s.ops.meta ? 1 : 0}${s.token ? 'a' : ''}]`);
+  log(`[harness] capabilities: ${caps.join(' ')}`);
+
+  // Timers
+  pacingStartMs = Date.now();
+  snap = { t: pacingStartMs, completed: 0, ok: 0, err: 0 };
+  timers.push(setInterval(() => {
+    if (stopping) return;
+    tokens += refillPerTick;
+    if (tokens > capacity) { M.totals.dropped += (tokens - capacity); tokens = capacity; }
+    pump();
+  }, tickMs));
+  timers.push(setInterval(() => report('progress'), REPORT_SEC * 1000));
+  timers.push(setInterval(() => { runSentinel().catch(() => {}); }, SENTINEL_SEC * 1000));
+  timers.push(setInterval(() => {
+    if (!AUTH) return;
+    const cutoff = Date.now() - RELOGIN_SEC * 1000;
+    for (const s of runtime) if (s.token && s.tokenAt < cutoff) scheduleRelogin(s);
+  }, 30000));
+
+  durationTimer = setTimeout(() => finish('duration'), DURATION_SEC * 1000);
+  const onSig = () => finish('signal');
+  process.on('SIGINT', onSig);
+  process.on('SIGTERM', onSig);
+
+  await donePromise;
+  await drain();
+  const out = finalize();
+
+  const c = out.byClass;
+  log(`[harness] DONE reason=${stopReason} wall=${out.wallSec}s load=${out.loadSec}s completed=${out.totals.completed} ok=${out.totals.ok} err=${out.totals.err} achievedRps=${out.totals.achievedRps} p50=${out.latencyOverall.p50} p95=${out.latencyOverall.p95} p99=${out.latencyOverall.p99}`);
+  log(`[harness] read ${c.read.ok}/${c.read.err} write ${c.write.ok}/${c.write.err}(created=${c.write.created} leaked=${c.write.leaked}) meta ${c.meta.ok}/${c.meta.err} | sentinel checks=${M.sentinel.checks} ownSeen=${M.sentinel.ownCanarySeen} violations=${M.sentinel.violations.length}`);
+  log(`[harness] wrote ${OUT}`);
+  if (!M.sentinel.ok) log('[harness] *** BLEED SENTINEL VIOLATION — exit 2 ***');
+}
+
+main().catch((err) => {
+  process.stderr.write(`[harness] FATAL: ${err && err.stack ? err.stack : err}\n`);
+  try { finalize(); } catch {}
+  process.exitCode = process.exitCode || 1;
+});
diff --git a/scripts/scale-validate/measure-instance-heap.mjs b/scripts/scale-validate/measure-instance-heap.mjs
new file mode 100644
index 0000000000..c0858f5ccf
--- /dev/null
+++ b/scripts/scale-validate/measure-instance-heap.mjs
@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+// =============================================================================
+// measure-instance-heap.mjs — per-class instance heap cost (V2 sizing input)
+//
+// Boots a FRESH cnc server (own child process, own metrics file), waits for the
+// metrics sampler baseline, cold-builds exactly ONE instance class by hitting a
+// single virtual host, lets the heap settle, and records the delta. Because the
+// server is fresh and only one host is ever hit, the delta IS the marginal cost
+// of the first resident instance of that class (instance + its share of lazily
+// initialized caches).
+//
+// Usage:
+//   node scripts/scale-validate/measure-instance-heap.mjs \
+//     --label tenant-api --host api-factory1-26c6da94.localhost \
+//     [--port 3344] [--heap-mb 2048] [--cache-max 1] [--settle-sec 70] \
+//     [--out scripts/scale-validate/out/instance-heap.jsonl]
+//
+// Env: PGHOST PGPORT PGUSER PGPASSWORD PGDATABASE (defaults :5433 constructive)
+// =============================================================================
+import { spawn } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKTREE = path.resolve(__dirname, '..', '..');
+
+const arg = (name, dflt) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > -1 ? process.argv[i + 1] : dflt;
+};
+const LABEL = arg('label', 'unlabeled');
+const HOST = arg('host', null);
+const PORT = parseInt(arg('port', '3344'), 10);
+const HEAP_MB = parseInt(arg('heap-mb', '2048'), 10);
+const CACHE_MAX = arg('cache-max', '1');
+const SETTLE_SEC = parseInt(arg('settle-sec', '70'), 10);
+const OUT = path.resolve(WORKTREE, arg('out', 'scripts/scale-validate/out/instance-heap.jsonl'));
+if (!HOST) {
+  console.error('--host is required');
+  process.exit(1);
+}
+
+const METRICS_FILE = path.resolve(
+  WORKTREE,
+  'scripts/scale-validate/out',
+  `metrics-cap1-${LABEL}.jsonl`
+);
+mkdirSync(path.dirname(METRICS_FILE), { recursive: true });
+if (existsSync(METRICS_FILE)) rmSync(METRICS_FILE);
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const MB = (b) => Math.round((b / 1024 / 1024) * 10) / 10;
+
+function readMetrics() {
+  if (!existsSync(METRICS_FILE)) return [];
+  return readFileSync(METRICS_FILE, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function waitForPort(port, timeoutMs) {
+  // The server binds "localhost", which on macOS may resolve to ::1 only —
+  // probe both families.
+  const hosts = ['127.0.0.1', '::1'];
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve, reject) => {
+    let i = 0;
+    const tryOnce = () => {
+      const host = hosts[i++ % hosts.length];
+      const sock = net.connect({ host, port }, () => {
+        sock.destroy();
+        resolve();
+      });
+      sock.on('error', () => {
+        sock.destroy();
+        if (Date.now() > deadline) reject(new Error(`port ${port} not listening after ${timeoutMs}ms`));
+        else setTimeout(tryOnce, 300);
+      });
+    };
+    tryOnce();
+  });
+}
+
+async function gql(host, port, timeoutMs) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  const start = performance.now();
+  try {
+    const res = await fetch(`http://${host}:${port}/graphql`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', accept: 'application/json' },
+      body: JSON.stringify({ query: 'query { __typename }' }),
+      signal: ac.signal
+    });
+    const body = await res.text();
+    return { status: res.status, ms: Math.round(performance.now() - start), body: body.slice(0, 200) };
+  } catch (e) {
+    return { status: 0, ms: Math.round(performance.now() - start), body: String(e).slice(0, 200) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+const main = async () => {
+  console.log(`[${LABEL}] starting server port=${PORT} heap=${HEAP_MB}MB cacheMax=${CACHE_MAX} host=${HOST}`);
+  const child = spawn(
+    'node',
+    [
+      'packages/cli/dist/index.js',
+      'server',
+      '--port',
+      String(PORT),
+      '--origin',
+      '*',
+      '--simpleInflection',
+      '--postgis',
+      '--servicesApi'
+    ],
+    {
+      cwd: WORKTREE,
+      env: {
+        ...process.env,
+        NODE_ENV: 'production',
+        NODE_OPTIONS: `--max-old-space-size=${HEAP_MB}`,
+        GRAPHILE_DEBUG_METRICS: '1',
+        GRAPHILE_DEBUG_METRICS_FILE: METRICS_FILE,
+        GRAPHILE_BLUEPRINT_POOLING: '1',
+        GRAPHILE_CACHE_MAX: CACHE_MAX,
+        PGHOST: process.env.PGHOST || 'localhost',
+        PGPORT: process.env.PGPORT || '5433',
+        PGUSER: process.env.PGUSER || 'postgres',
+        PGPASSWORD: process.env.PGPASSWORD || 'password',
+        PGDATABASE: process.env.PGDATABASE || 'constructive'
+      },
+      stdio: ['ignore', 'pipe', 'pipe']
+    }
+  );
+  let serverLog = '';
+  child.stdout.on('data', (d) => (serverLog += d));
+  child.stderr.on('data', (d) => (serverLog += d));
+  let exited = false;
+  child.on('exit', () => (exited = true));
+
+  const result = { label: LABEL, host: HOST, heapMb: HEAP_MB, cacheMax: CACHE_MAX, ok: false };
+  try {
+    await waitForPort(PORT, 120000);
+    console.log(`[${LABEL}] listening; waiting for baseline metrics...`);
+
+    // Baseline: at least 2 sampler lines (20s) so init transients are past.
+    let m = [];
+    const baseDeadline = Date.now() + 90000;
+    while (Date.now() < baseDeadline) {
+      m = readMetrics();
+      if (m.length >= 2) break;
+      await sleep(2000);
+    }
+    if (m.length < 2) throw new Error(`no metrics baseline (${m.length} lines): sampler not writing?`);
+    const baseline = m[m.length - 1];
+    const baselineCount = m.length;
+    result.baseline = { heapUsedMB: MB(baseline.heapUsed), rssMB: MB(baseline.rss) };
+    console.log(`[${LABEL}] baseline heapUsed=${result.baseline.heapUsedMB}MB rss=${result.baseline.rssMB}MB`);
+
+    // Cold build: first request to this host builds the instance.
+    const cold = await gql(HOST, PORT, 420000);
+    result.cold = cold;
+    console.log(`[${LABEL}] cold request: status=${cold.status} ${cold.ms}ms ${cold.body}`);
+    if (cold.status !== 200) throw new Error(`cold request failed: ${cold.status} ${cold.body}`);
+
+    // Settle and sample.
+    const targetLines = baselineCount + Math.ceil(SETTLE_SEC / 10);
+    const settleDeadline = Date.now() + SETTLE_SEC * 1000 + 60000;
+    while (Date.now() < settleDeadline) {
+      m = readMetrics();
+      if (m.length >= targetLines) break;
+      await sleep(5000);
+    }
+    const post = m.slice(baselineCount);
+    if (post.length === 0) throw new Error('no post-build metrics samples');
+    const last = post[post.length - 1];
+    const heaps = post.map((x) => x.heapUsed);
+    const rsss = post.map((x) => x.rss);
+    result.postBuild = {
+      samples: post.length,
+      heapUsedLastMB: MB(last.heapUsed),
+      heapUsedMinMB: MB(Math.min(...heaps)),
+      heapUsedMaxMB: MB(Math.max(...heaps)),
+      rssLastMB: MB(last.rss),
+      rssMaxMB: MB(Math.max(...rsss)),
+      cache: last.cache,
+      counters: last.counters
+    };
+    result.deltaHeapMB = Math.round((result.postBuild.heapUsedLastMB - result.baseline.heapUsedMB) * 10) / 10;
+    result.deltaRssMB = Math.round((result.postBuild.rssLastMB - result.baseline.rssMB) * 10) / 10;
+
+    // Warm request: instance resident, should be fast.
+    const warm = await gql(HOST, PORT, 30000);
+    result.warm = { status: warm.status, ms: warm.ms };
+    result.ok = warm.status === 200;
+    console.log(
+      `[${LABEL}] deltaHeap=${result.deltaHeapMB}MB deltaRss=${result.deltaRssMB}MB ` +
+        `(post last=${result.postBuild.heapUsedLastMB}MB min=${result.postBuild.heapUsedMinMB}MB ` +
+        `max=${result.postBuild.heapUsedMaxMB}MB) warm=${warm.ms}ms`
+    );
+  } catch (e) {
+    result.error = String(e && e.message ? e.message : e);
+    result.serverLogTail = serverLog.slice(-1500);
+    console.error(`[${LABEL}] FAILED: ${result.error}`);
+  } finally {
+    if (!exited) {
+      child.kill('SIGTERM');
+      const killDeadline = Date.now() + 15000;
+      while (!exited && Date.now() < killDeadline) await sleep(500);
+      if (!exited) child.kill('SIGKILL');
+    }
+  }
+
+  appendFileSync(OUT, JSON.stringify(result) + '\n');
+  console.log(`[${LABEL}] result appended to ${OUT}`);
+  if (!result.ok) process.exitCode = 1;
+};
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
diff --git a/scripts/scale-validate/pg-sampler.mjs b/scripts/scale-validate/pg-sampler.mjs
new file mode 100644
index 0000000000..c84ffc3bb5
--- /dev/null
+++ b/scripts/scale-validate/pg-sampler.mjs
@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+/**
+ * pg-sampler.mjs — PG-side time series for perf runs (the node side is covered
+ * by the server's GRAPHILE_DEBUG_METRICS JSONL; this captures the Postgres half).
+ *
+ * Every --interval-sec appends one JSONL line to --out with:
+ *   - docker container memory (usage/limit bytes) for --container
+ *   - pg_stat_activity backend counts by state (+ total)
+ *   - pg_class row count (catalog size proxy) and current database size
+ *
+ * Connection: standard PG* env vars (or --pg-* flags via pgConfigFromArgs).
+ * A FRESH client per sample (rig runs idle_session_timeout=120s; a persistent
+ * idle client would be reaped mid-run). Sampling errors are recorded on the
+ * line ({err}) and never kill the sampler — a PG crash/recovery window is
+ * exactly the data we want to keep collecting through.
+ *
+ * Exit: --duration-sec elapsed, or SIGINT/SIGTERM (JSONL is append-per-line,
+ * nothing to flush).
+ */
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { asInt, nowIso, parseArgs, pgConfigFromArgs, resolvePg, sleep } from './_lib.mjs';
+
+const { args } = parseArgs(process.argv.slice(2));
+if (args.help) {
+  console.log(`usage: node pg-sampler.mjs [--out out/pg-soak.jsonl] [--interval-sec 30]
+       [--duration-sec 0=until signal] [--container constructive-scale-pg]
+       PG* env / --pg-* flags        connection overrides`);
+  process.exit(0);
+}
+
+const OUT = args.out || 'out/pg-soak.jsonl';
+const INTERVAL_SEC = asInt(args['interval-sec'], 30);
+const DURATION_SEC = asInt(args['duration-sec'], 0);
+const CONTAINER = args.container || 'constructive-scale-pg';
+
+const { Client } = resolvePg();
+const pgConfig = pgConfigFromArgs(args);
+
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+
+let stopping = false;
+process.on('SIGINT', () => { stopping = true; });
+process.on('SIGTERM', () => { stopping = true; });
+
+function dockerMem(name) {
+  return new Promise((resolve) => {
+    execFile('docker', ['stats', '--no-stream', '--format', '{{.MemUsage}}', name],
+      { timeout: 10_000 }, (err, stdout) => {
+        if (err) return resolve({ err: String(err.message || err).slice(0, 200) });
+        // e.g. "1.234GiB / 4GiB"
+        const m = String(stdout).trim();
+        const toBytes = (s) => {
+          const mm = /([\d.]+)\s*(B|KiB|MiB|GiB)/.exec(s);
+          if (!mm) return null;
+          const mult = { B: 1, KiB: 1024, MiB: 1024 ** 2, GiB: 1024 ** 3 }[mm[2]];
+          return Math.round(parseFloat(mm[1]) * mult);
+        };
+        const [used, limit] = m.split('/').map((s) => toBytes(s));
+        resolve({ raw: m, usedBytes: used, limitBytes: limit });
+      });
+  });
+}
+
+async function pgSample() {
+  const client = new Client(pgConfig);
+  try {
+    await client.connect();
+    // sequential on purpose: pg queues concurrent query() on one client (deprecated)
+    const act = await client.query('SELECT COALESCE(state, \'null\') AS state, count(*)::int AS n FROM pg_stat_activity GROUP BY 1');
+    const cls = await client.query('SELECT count(*)::int AS n FROM pg_class');
+    const size = await client.query('SELECT pg_database_size(current_database())::bigint AS b, (SELECT sum(numbackends)::int FROM pg_stat_database) AS backends');
+    const byState = {};
+    let total = 0;
+    for (const r of act.rows) { byState[r.state] = r.n; total += r.n; }
+    return {
+      backendsByState: byState,
+      backendsTotal: total,
+      backendsAllDbs: size.rows[0].backends,
+      pgClassRows: cls.rows[0].n,
+      dbSizeBytes: Number(size.rows[0].b)
+    };
+  } finally {
+    try { await client.end(); } catch { /* recovery window; line already has data or err */ }
+  }
+}
+
+const startMs = Date.now();
+console.log(`[pg-sampler] out=${OUT} interval=${INTERVAL_SEC}s duration=${DURATION_SEC || 'until-signal'}s container=${CONTAINER} pg=${pgConfig.host}:${pgConfig.port}/${pgConfig.database}`);
+
+for (;;) {
+  if (stopping) break;
+  if (DURATION_SEC && (Date.now() - startMs) / 1000 >= DURATION_SEC) break;
+  const line = { t: nowIso() };
+  try {
+    line.docker = await dockerMem(CONTAINER);
+  } catch (e) {
+    line.docker = { err: String(e.message || e).slice(0, 200) };
+  }
+  try {
+    Object.assign(line, await pgSample());
+  } catch (e) {
+    line.err = String(e.message || e).slice(0, 200);
+  }
+  fs.appendFileSync(OUT, `${JSON.stringify(line)}\n`);
+  // sleep in small slices so signals stay responsive
+  const until = Date.now() + INTERVAL_SEC * 1000;
+  while (Date.now() < until && !stopping) await sleep(500);
+}
+console.log('[pg-sampler] done');
diff --git a/scripts/scale-validate/plans/v2-1152.json b/scripts/scale-validate/plans/v2-1152.json
new file mode 100644
index 0000000000..61b9f38190
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-1152.json
@@ -0,0 +1,13 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 1152,
+    "rps": 10,
+    "durationSec": 300,
+    "shape": "uniform",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05",
+    "serverEnv": { "GRAPHILE_CACHE_INSTANCE_HEAP_BYTES": "1450000000" }
+  },
+  "steps": [{ "name": "floor-div-k1", "fleet": "out/fleet-k1.json" }]
+}
diff --git a/scripts/scale-validate/plans/v2-1536.json b/scripts/scale-validate/plans/v2-1536.json
new file mode 100644
index 0000000000..f769e579c4
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-1536.json
@@ -0,0 +1,13 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 1536,
+    "rps": 10,
+    "durationSec": 300,
+    "shape": "uniform",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05",
+    "serverEnv": { "GRAPHILE_CACHE_INSTANCE_HEAP_BYTES": "1450000000" }
+  },
+  "steps": [{ "name": "floor-div-k1", "fleet": "out/fleet-k1.json" }]
+}
diff --git a/scripts/scale-validate/plans/v2-2048-rps-single.json b/scripts/scale-validate/plans/v2-2048-rps-single.json
new file mode 100644
index 0000000000..933ec0d6cb
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-2048-rps-single.json
@@ -0,0 +1,16 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 2048,
+    "durationSec": 300,
+    "shape": "zipf",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05",
+    "serverEnv": { "GRAPHILE_CACHE_INSTANCE_HEAP_BYTES": "1450000000" }
+  },
+  "steps": [
+    { "name": "rps-s-50", "fleet": "out/fleet-t33.json", "rps": 50 },
+    { "name": "rps-s-100", "fleet": "out/fleet-t33.json", "rps": 100 },
+    { "name": "rps-s-200", "fleet": "out/fleet-t33.json", "rps": 200 }
+  ]
+}
diff --git a/scripts/scale-validate/plans/v2-2048-tuned.json b/scripts/scale-validate/plans/v2-2048-tuned.json
new file mode 100644
index 0000000000..f61948de68
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-2048-tuned.json
@@ -0,0 +1,26 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 2048,
+    "rps": 10,
+    "durationSec": 480,
+    "shape": "uniform",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05",
+    "serverEnv": { "GRAPHILE_CACHE_INSTANCE_HEAP_BYTES": "1450000000" }
+  },
+  "steps": [
+    { "name": "tuned-div-k1", "fleet": "out/fleet-k1.json" },
+    { "name": "tuned-div-k2", "fleet": "out/fleet-k2.json" },
+    { "name": "tuned-div-k3", "fleet": "out/fleet-k3.json" },
+    { "name": "tuned-div-k5", "fleet": "out/fleet-k5.json" },
+    { "name": "tuned-ten-10", "fleet": "out/fleet-t10.json", "shape": "zipf", "rps": 15 },
+    { "name": "tuned-ten-20", "fleet": "out/fleet-t20.json", "shape": "zipf", "rps": 15 },
+    { "name": "tuned-ten-33", "fleet": "out/fleet-t33.json", "shape": "zipf", "rps": 15 },
+    { "name": "tuned-rps-10", "fleet": "fleet.json", "shape": "zipf", "rps": 10, "durationSec": 300 },
+    { "name": "tuned-rps-25", "fleet": "fleet.json", "shape": "zipf", "rps": 25, "durationSec": 300 },
+    { "name": "tuned-rps-50", "fleet": "fleet.json", "shape": "zipf", "rps": 50, "durationSec": 300 },
+    { "name": "tuned-rps-100", "fleet": "fleet.json", "shape": "zipf", "rps": 100, "durationSec": 300 },
+    { "name": "tuned-cold-burst", "fleet": "out/fleet-burst.json", "coldBurst": true }
+  ]
+}
diff --git a/scripts/scale-validate/plans/v2-2048.json b/scripts/scale-validate/plans/v2-2048.json
new file mode 100644
index 0000000000..b2143c9226
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-2048.json
@@ -0,0 +1,25 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 2048,
+    "rps": 10,
+    "durationSec": 480,
+    "shape": "uniform",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05"
+  },
+  "steps": [
+    { "name": "div-k1", "fleet": "out/fleet-k1.json" },
+    { "name": "div-k2", "fleet": "out/fleet-k2.json" },
+    { "name": "div-k3", "fleet": "out/fleet-k3.json" },
+    { "name": "div-k5", "fleet": "out/fleet-k5.json" },
+    { "name": "ten-10", "fleet": "out/fleet-t10.json", "shape": "zipf", "rps": 15 },
+    { "name": "ten-20", "fleet": "out/fleet-t20.json", "shape": "zipf", "rps": 15 },
+    { "name": "ten-33", "fleet": "out/fleet-t33.json", "shape": "zipf", "rps": 15 },
+    { "name": "rps-10", "fleet": "fleet.json", "shape": "zipf", "rps": 10, "durationSec": 300 },
+    { "name": "rps-25", "fleet": "fleet.json", "shape": "zipf", "rps": 25, "durationSec": 300 },
+    { "name": "rps-50", "fleet": "fleet.json", "shape": "zipf", "rps": 50, "durationSec": 300 },
+    { "name": "rps-100", "fleet": "fleet.json", "shape": "zipf", "rps": 100, "durationSec": 300 },
+    { "name": "cold-burst", "fleet": "out/fleet-burst.json", "coldBurst": true }
+  ]
+}
diff --git a/scripts/scale-validate/plans/v2-3584-r2.json b/scripts/scale-validate/plans/v2-3584-r2.json
new file mode 100644
index 0000000000..1139c279c8
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-3584-r2.json
@@ -0,0 +1,13 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 3584,
+    "rps": 10,
+    "durationSec": 420,
+    "shape": "uniform",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05",
+    "serverEnv": { "GRAPHILE_CACHE_INSTANCE_HEAP_BYTES": "896000000" }
+  },
+  "steps": [{ "name": "r2-div-k1", "fleet": "out/fleet-k1.json" }]
+}
diff --git a/scripts/scale-validate/plans/v2-3584.json b/scripts/scale-validate/plans/v2-3584.json
new file mode 100644
index 0000000000..892ef2d0f7
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-3584.json
@@ -0,0 +1,19 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 3584,
+    "rps": 10,
+    "durationSec": 420,
+    "shape": "uniform",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05",
+    "serverEnv": { "GRAPHILE_CACHE_INSTANCE_HEAP_BYTES": "1450000000" }
+  },
+  "steps": [
+    { "name": "big-div-k1", "fleet": "out/fleet-k1.json" },
+    { "name": "big-div-k3", "fleet": "out/fleet-k3.json" },
+    { "name": "big-div-k5", "fleet": "out/fleet-k5.json" },
+    { "name": "big-ten-10", "fleet": "out/fleet-t10.json", "shape": "zipf", "rps": 15 },
+    { "name": "big-ten-33", "fleet": "out/fleet-t33.json", "shape": "zipf", "rps": 15 }
+  ]
+}
diff --git a/scripts/scale-validate/plans/v2-896.json b/scripts/scale-validate/plans/v2-896.json
new file mode 100644
index 0000000000..f85f03360b
--- /dev/null
+++ b/scripts/scale-validate/plans/v2-896.json
@@ -0,0 +1,13 @@
+{
+  "port": 3345,
+  "defaults": {
+    "heapMb": 896,
+    "rps": 10,
+    "durationSec": 300,
+    "shape": "uniform",
+    "auth": 1,
+    "mix": "read:0.7,write:0.25,meta:0.05",
+    "serverEnv": { "GRAPHILE_CACHE_INSTANCE_HEAP_BYTES": "1450000000" }
+  },
+  "steps": [{ "name": "floor-div-k1", "fleet": "out/fleet-k1.json" }]
+}
diff --git a/scripts/scale-validate/soak-ops.mjs b/scripts/scale-validate/soak-ops.mjs
new file mode 100644
index 0000000000..6114d9509c
--- /dev/null
+++ b/scripts/scale-validate/soak-ops.mjs
@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// =============================================================================
+// soak-ops.mjs — V3 soak operations churn: cycle tenant provisioning/teardown.
+//
+// Every --interval-sec: provision ONE new tenant (tenant-factory, own prefix),
+// then drop the tenant created by the PREVIOUS cycle. Net effect: the soak
+// continuously exercises the full provision + teardown paths (catalog writes,
+// schema:update NOTIFY -> flush -> rebuild on next hit) WITHOUT net catalog
+// growth — important because instance heap scales ~21KB/pg_class row, so
+// unbounded provisioning would inflate the resident instance past a 2GB heap
+// mid-soak and turn a longevity test into a slow OOM test.
+//
+// Usage:
+//   node scripts/scale-validate/soak-ops.mjs --interval-sec 7200 \
+//     --duration-sec 86400 [--prefix soak]
+// Env: PGHOST PGPORT PGUSER PGPASSWORD PGDATABASE (defaults :5433 constructive)
+// =============================================================================
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const arg = (name, dflt) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > -1 ? process.argv[i + 1] : dflt;
+};
+const INTERVAL_SEC = parseInt(arg('interval-sec', '7200'), 10);
+const DURATION_SEC = parseInt(arg('duration-sec', '86400'), 10);
+const PREFIX = arg('prefix', 'soak');
+
+const run = (script, args) => {
+  const res = spawnSync('node', [path.join(__dirname, script), ...args], {
+    env: process.env,
+    encoding: 'utf8',
+    timeout: 30 * 60 * 1000
+  });
+  const out = `${res.stdout || ''}${res.stderr || ''}`;
+  return { status: res.status, out, tail: out.split('\n').filter(Boolean).slice(-3).join(' | ') };
+};
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const now = () => new Date().toISOString();
+
+const main = async () => {
+  const deadline = Date.now() + DURATION_SEC * 1000;
+  let cycle = 0;
+  let previousName = null;
+
+  console.log(`[soak-ops] ${now()} start: interval=${INTERVAL_SEC}s duration=${DURATION_SEC}s prefix=${PREFIX}`);
+
+  while (Date.now() < deadline) {
+    cycle++;
+    const t0 = Date.now();
+
+    const create = run('tenant-factory.mjs', ['--count', '1', '--prefix', PREFIX, '--blueprint', 'marketplace']);
+    // tenant-factory auto-picks the next free index; recover the name it made.
+    const m = /\[(\w+)\] OK db=/.exec(create.out) || /indices=(\d+)\.\./.exec(create.out);
+    const createdName = m ? (m[1].startsWith(PREFIX) ? m[1] : `${PREFIX}${m[1]}`) : null;
+    console.log(
+      `[soak-ops] ${now()} cycle=${cycle} provision status=${create.status} created=${createdName || '?'} :: ${create.tail}`
+    );
+
+    if (previousName) {
+      const drop = run('drop-tenants.mjs', ['--only', previousName]);
+      console.log(`[soak-ops] ${now()} cycle=${cycle} drop ${previousName} status=${drop.status} :: ${drop.tail}`);
+    }
+    previousName = createdName || previousName;
+
+    const elapsed = Date.now() - t0;
+    const wait = Math.max(0, INTERVAL_SEC * 1000 - elapsed);
+    if (Date.now() + wait >= deadline) break;
+    await sleep(wait);
+  }
+
+  // Final cleanup: drop the last soak tenant so the fleet is back to baseline.
+  if (previousName) {
+    const drop = run('drop-tenants.mjs', ['--only', previousName]);
+    console.log(`[soak-ops] ${now()} final cleanup ${previousName} status=${drop.status}`);
+  }
+  console.log(`[soak-ops] ${now()} done after ${cycle} cycles`);
+};
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
diff --git a/scripts/scale-validate/subset-fleet.mjs b/scripts/scale-validate/subset-fleet.mjs
new file mode 100644
index 0000000000..9c1e2af2ad
--- /dev/null
+++ b/scripts/scale-validate/subset-fleet.mjs
@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+// =============================================================================
+// subset-fleet.mjs — derive ramp-specific fleet manifests from fleet.json +
+// drifted.json (V2 limits discovery).
+//
+// Blueprint groups: group 0 = undrifted tenants (majority blueprint; includes
+// column-drift tenants — same relname set => same blueprint), groups 1..K =
+// drift_marker_g<g> table-drift groups from drift-tenants.mjs.
+//
+// Modes:
+//   --blueprints K --per-blueprint N   diversity subset: first K groups
+//                                      (0,1,2,...), N tenants from each →
+//                                      K distinct blueprints, K*N tenants.
+//   --tenants N                        tenant-count subset: N undrifted
+//                                      (group-0) tenants → 1 blueprint.
+//
+// Usage:
+//   node scripts/scale-validate/subset-fleet.mjs --fleet fleet.json \
+//     --drifted drifted.json --blueprints 3 --per-blueprint 5 --out out/fleet-k3.json
+//   node scripts/scale-validate/subset-fleet.mjs --fleet fleet.json \
+//     --drifted drifted.json --tenants 50 --out out/fleet-t50.json
+// =============================================================================
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const arg = (name, dflt) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > -1 ? process.argv[i + 1] : dflt;
+};
+
+const FLEET = path.resolve(__dirname, arg('fleet', 'fleet.json'));
+const DRIFTED = path.resolve(__dirname, arg('drifted', 'drifted.json'));
+const BLUEPRINTS = parseInt(arg('blueprints', '0'), 10);
+const PER_BLUEPRINT = parseInt(arg('per-blueprint', '5'), 10);
+const TENANTS = parseInt(arg('tenants', '0'), 10);
+const OUT = path.resolve(__dirname, arg('out', ''));
+if (!OUT || OUT === __dirname) {
+  console.error('--out is required');
+  process.exit(1);
+}
+
+const fleet = JSON.parse(fs.readFileSync(FLEET, 'utf8'));
+const drifted = JSON.parse(fs.readFileSync(DRIFTED, 'utf8'));
+const all = fleet.tenants;
+const byName = new Map(all.map((t) => [t.dbname, t]));
+
+const driftedNames = new Set();
+for (const names of Object.values(drifted.groups || {})) names.forEach((n) => driftedNames.add(n));
+
+// group 0 = the KNOWN-identical blueprint pool, minus table-drifted tenants.
+// Factory tenants are clones of marketplace_db_tenant1 (fingerprint-validated);
+// other seeder tenants (tenant2...) have DIVERGENT shapes — never group 0.
+// Column-drift tenants keep their relname set => still the same blueprint.
+const SAME_BP_RE = new RegExp(arg('same-bp-regex', '^(factory[0-9]+|marketplace_db_tenant1)$'));
+const group0 = all
+  .filter((t) => SAME_BP_RE.test(t.dbname) && !driftedNames.has(t.dbname))
+  .map((t) => t.dbname);
+const groups = [group0];
+for (const g of Object.keys(drifted.groups || {}).sort((a, b) => Number(a) - Number(b))) {
+  groups.push(drifted.groups[g]);
+}
+
+let picked = [];
+let label = '';
+if (BLUEPRINTS > 0) {
+  if (BLUEPRINTS > groups.length) {
+    console.error(`only ${groups.length} blueprint groups available, asked for ${BLUEPRINTS}`);
+    process.exit(1);
+  }
+  for (let k = 0; k < BLUEPRINTS; k++) {
+    const take = groups[k].slice(0, PER_BLUEPRINT);
+    if (take.length < PER_BLUEPRINT)
+      console.error(`warn: group ${k} has only ${take.length}/${PER_BLUEPRINT} tenants`);
+    picked.push(...take);
+  }
+  label = `diversity k=${BLUEPRINTS} per=${PER_BLUEPRINT}`;
+} else if (TENANTS > 0) {
+  picked = group0.slice(0, TENANTS);
+  if (picked.length < TENANTS)
+    console.error(`warn: only ${picked.length}/${TENANTS} undrifted tenants available`);
+  label = `tenant-count n=${picked.length} (single blueprint)`;
+} else {
+  console.error('one of --blueprints or --tenants is required');
+  process.exit(1);
+}
+
+const tenants = picked.map((n) => byName.get(n)).filter(Boolean);
+const missing = picked.filter((n) => !byName.has(n));
+if (missing.length) console.error(`warn: ${missing.length} drifted names not in fleet: ${missing.join(',')}`);
+
+const manifest = {
+  generatedAt: new Date().toISOString(),
+  derivedFrom: FLEET,
+  subset: label,
+  count: tenants.length,
+  tenants
+};
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+fs.writeFileSync(OUT, JSON.stringify(manifest) + '\n');
+console.log(`[subset] ${label}: ${tenants.length} tenants -> ${OUT}`);
diff --git a/scripts/scale-validate/summarize-results.mjs b/scripts/scale-validate/summarize-results.mjs
new file mode 100644
index 0000000000..e790050bbe
--- /dev/null
+++ b/scripts/scale-validate/summarize-results.mjs
@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Summarize v2-ramps result JSONL files: one line per step.
+// Usage: node summarize-results.mjs out/v2-2048-tuned-results.jsonl [...more]
+import fs from 'node:fs';
+
+for (const file of process.argv.slice(2)) {
+  if (!fs.existsSync(file)) {
+    console.log(`-- ${file}: missing`);
+    continue;
+  }
+  console.log(`== ${file}`);
+  for (const line of fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean)) {
+    let r;
+    try {
+      r = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const s = r.summary || {};
+    const lat = s.latency || {};
+    const m = r.metrics || {};
+    const c = m.lastCounters || {};
+    const out = [
+      r.name,
+      `crashed=${r.serverCrashed ? JSON.stringify(r.serverExit) : false}`,
+      `err=${r.error || '-'}`,
+      s.errRate !== undefined ? `errRate=${s.errRate}` : null,
+      s.achievedRps !== undefined ? `rps=${s.achievedRps}` : null,
+      lat.p50 !== undefined ? `p50/p95/p99=${lat.p50}/${lat.p95}/${lat.p99}` : null,
+      s.http ? `http=${JSON.stringify(s.http)}` : null,
+      s.sentinelOk !== undefined ? `sentinelOk=${s.sentinelOk}` : null,
+      r.coldBurst ? `cold=${JSON.stringify(s)}` : null,
+      m.heapUsedMaxMB !== undefined ? `heapMax=${m.heapUsedMaxMB}MB` : null,
+      m.rssMaxMB !== undefined ? `rssMax=${m.rssMaxMB}MB` : null,
+      m.buildQueueDepthMax !== undefined ? `queueMax=${m.buildQueueDepthMax}` : null,
+      c.evictions ? `evict=${JSON.stringify(c.evictions)}` : null,
+      c.builds !== undefined ? `builds=${c.builds}` : null,
+      c.connGuard ? `connGuard=${JSON.stringify(c.connGuard)}` : null,
+      r.pgBackends ? `pgConnMax=${r.pgBackends.max}${r.pgBackends.reconnects ? ` reconn=${r.pgBackends.reconnects}` : ''}` : null,
+      `wall=${r.wallSec}s`
+    ]
+      .filter(Boolean)
+      .join(' | ');
+    console.log('  ' + out);
+  }
+}
diff --git a/scripts/scale-validate/tenant-factory.mjs b/scripts/scale-validate/tenant-factory.mjs
new file mode 100644
index 0000000000..69f0760dfe
--- /dev/null
+++ b/scripts/scale-validate/tenant-factory.mjs
@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+// =============================================================================
+// tenant-factory.mjs — the 200-tenant fast path (TASK D spike)
+//
+// Creates blueprint-identical marketplace tenants directly via SQL, reusing the
+// SAME control-plane procedures the GraphQL seeder ultimately invokes, but
+// WITHOUT the GraphQL/undici layer (and its 300s HTTP cap). Per tenant it runs,
+// in one committed transaction:
+//
+//   1. metaschema_generators.provision_database(...)   — db + domains + apis +
+//        site + ~40 modules + the app_public/app_private application schemas.
+//   2. metaschema_private.bootstrap_owner_into_database(...) — copies the owner
+//        user + primary email + password_hash from the control-plane ("source")
+//        database into the new tenant so password sign-in works (this is what the
+//        seeder's async provision trigger does when bootstrap_user = true).
+//   3. INSERT metaschema_modules_public.blueprint (copy of the reference
+//        marketplace definition) + metaschema_modules_public.construct_blueprint(
+//        blueprint_id, app_public_schema_id) — builds the 5 marketplace tables
+//        (categories, products, orders, order_items, reviews) into app_public.
+//
+// Session GUC: the module install triggers (events/function/config/agent/...) call
+// metaschema_private.ensure_super_constructive(), which RAISES unless
+// `constructive.allow_super_constructive = 'true'`. We set it per-transaction.
+//
+// Usage:
+//   node scripts/scale-validate/tenant-factory.mjs --count 5 --prefix factory \
+//        --blueprint marketplace [--concurrency 1] [--dry-run]
+//   node scripts/scale-validate/tenant-factory.mjs --validate factory1   # shape check vs reference
+//
+// Env: PGHOST PGPORT PGUSER PGPASSWORD PGDATABASE (defaults target :5433 constructive)
+// =============================================================================
+
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import crypto from 'crypto';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKTREE = path.resolve(__dirname, '..', '..');
+
+// `pg` is not a root dep; resolve it via the @dataplan/pg chain (same trick the
+// other scale-spike scripts use).
+const rootRequire = createRequire(path.join(WORKTREE, 'graphql', 'query', 'package.json'));
+const requireDpAdaptor = createRequire(rootRequire.resolve('postgraphile/adaptors/pg'));
+const requireDataplan = createRequire(requireDpAdaptor.resolve('@dataplan/pg'));
+const { Pool } = requireDataplan('pg');
+
+// ---------------------------------------------------------------------------
+// args
+// ---------------------------------------------------------------------------
+function parseArgs(argv) {
+  const out = {
+    count: 1,
+    prefix: 'factory',
+    blueprint: 'marketplace',
+    reference: 'marketplace_db_tenant1',
+    sourceDb: 'constructive',
+    domain: 'localhost',
+    concurrency: 1,
+    maxRetries: 3,
+    dryRun: false,
+    validate: null,
+    startIndex: null
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    if (a === '--count') out.count = parseInt(next(), 10);
+    else if (a === '--prefix') out.prefix = next();
+    else if (a === '--blueprint') out.blueprint = next();
+    else if (a === '--reference') out.reference = next();
+    else if (a === '--source-db') out.sourceDb = next();
+    else if (a === '--domain') out.domain = next();
+    else if (a === '--concurrency') out.concurrency = parseInt(next(), 10);
+    else if (a === '--max-retries') out.maxRetries = parseInt(next(), 10);
+    else if (a === '--start-index') out.startIndex = parseInt(next(), 10);
+    else if (a === '--dry-run') out.dryRun = true;
+    else if (a === '--validate') out.validate = next();
+    else throw new Error(`unknown arg: ${a}`);
+  }
+  return out;
+}
+
+const PG = {
+  host: process.env.PGHOST || 'localhost',
+  port: parseInt(process.env.PGPORT || '5433', 10),
+  user: process.env.PGUSER || 'postgres',
+  password: process.env.PGPASSWORD || 'password',
+  database: process.env.PGDATABASE || 'constructive'
+};
+
+const ms = (t) => `${(Number(t) / 1e6).toFixed(0)}ms`;
+const now = () => process.hrtime.bigint();
+
+// ---------------------------------------------------------------------------
+// reference loading
+// ---------------------------------------------------------------------------
+async function loadReference(pool, opts) {
+  const ref = await pool.query(
+    `SELECT d.id AS db_id, d.owner_id
+       FROM metaschema_public.database d
+      WHERE d.name = $1`,
+    [opts.reference]
+  );
+  if (ref.rows.length === 0) throw new Error(`reference database "${opts.reference}" not found`);
+  const { db_id: refDbId, owner_id: ownerId } = ref.rows[0];
+
+  const prov = await pool.query(
+    `SELECT modules, options, domain
+       FROM metaschema_modules_public.database_provision_module
+      WHERE database_id = $1
+      ORDER BY created_at
+      LIMIT 1`,
+    [refDbId]
+  );
+  if (prov.rows.length === 0)
+    throw new Error(`no database_provision_module row for reference "${opts.reference}"`);
+  const modules = prov.rows[0].modules;
+  const options = prov.rows[0].options;
+
+  const bp = await pool.query(
+    `SELECT name, display_name, definition
+       FROM metaschema_modules_public.blueprint
+      WHERE database_id = $1 AND name = $2`,
+    [refDbId, opts.blueprint]
+  );
+  if (bp.rows.length === 0)
+    throw new Error(`reference blueprint "${opts.blueprint}" not found on "${opts.reference}"`);
+  const blueprint = bp.rows[0];
+
+  const src = await pool.query(
+    `SELECT id FROM metaschema_public.database WHERE name = $1`,
+    [opts.sourceDb]
+  );
+  if (src.rows.length === 0) throw new Error(`source database "${opts.sourceDb}" not found`);
+  const sourceDbId = src.rows[0].id;
+
+  return { refDbId, ownerId, modules, options, blueprint, sourceDbId };
+}
+
+async function nextStartIndex(pool, prefix) {
+  const r = await pool.query(
+    `SELECT COALESCE(MAX((regexp_replace(name, '^' || $1, ''))::int), 0) AS mx
+       FROM metaschema_public.database
+      WHERE name ~ ('^' || $1 || '[0-9]+$')`,
+    [prefix]
+  );
+  return (r.rows[0].mx || 0) + 1;
+}
+
+// ---------------------------------------------------------------------------
+// per-tenant provisioning (one committed transaction)
+// ---------------------------------------------------------------------------
+async function createTenant(pool, ref, opts, index) {
+  const name = `${opts.prefix}${index}`;
+  const subdomain = `${name}-${crypto.randomBytes(4).toString('hex')}`;
+
+  let attempt = 0;
+  for (;;) {
+    attempt++;
+    const client = await pool.connect();
+    const t = {};
+    try {
+      await client.query('BEGIN');
+      await client.query('SET LOCAL statement_timeout = 0');
+      await client.query('SET LOCAL idle_in_transaction_session_timeout = 0');
+      await client.query('SET LOCAL lock_timeout = 0');
+      await client.query(`SET LOCAL constructive.allow_super_constructive = 'true'`);
+
+      // Phase 1: provision_database
+      let s = now();
+      const provRes = await client.query(
+        `SELECT metaschema_generators.provision_database($1,$2,$3,$4,$5::jsonb,$6::jsonb) AS db_id`,
+        [name, ref.ownerId, subdomain, opts.domain, JSON.stringify(ref.modules), JSON.stringify(ref.options)]
+      );
+      const dbId = provRes.rows[0].db_id;
+      t.provision = now() - s;
+
+      // Phase 2: bootstrap owner (password sign-in path)
+      s = now();
+      await client.query(
+        `SELECT metaschema_private.bootstrap_owner_into_database($1,$2,$3,false)`,
+        [dbId, ref.sourceDbId, ref.ownerId]
+      );
+      t.bootstrap = now() - s;
+
+      // Phase 3: blueprint copy + construct
+      s = now();
+      const bpRes = await client.query(
+        `INSERT INTO metaschema_modules_public.blueprint
+           (owner_id, database_id, name, display_name, definition)
+         VALUES ($1,$2,$3,$4,$5::jsonb)
+         RETURNING id`,
+        [ref.ownerId, dbId, ref.blueprint.name, ref.blueprint.display_name, JSON.stringify(ref.blueprint.definition)]
+      );
+      const blueprintId = bpRes.rows[0].id;
+      const schemaRes = await client.query(
+        `SELECT id, schema_name FROM metaschema_public.schema
+          WHERE database_id = $1 AND name = 'app_public'`,
+        [dbId]
+      );
+      if (schemaRes.rows.length === 0) throw new Error('app_public schema not found after provision');
+      const appPublicSchemaId = schemaRes.rows[0].id;
+      const appPublicPhysical = schemaRes.rows[0].schema_name;
+      await client.query(`SELECT metaschema_modules_public.construct_blueprint($1,$2)`, [
+        blueprintId,
+        appPublicSchemaId
+      ]);
+      t.blueprint = now() - s;
+
+      // Phase 4: in-txn verification
+      const verify = {};
+      verify.schemaCount = (
+        await client.query(
+          `SELECT count(*)::int AS c FROM metaschema_public.schema WHERE database_id=$1`,
+          [dbId]
+        )
+      ).rows[0].c;
+      verify.appTables = (
+        await client.query(
+          `SELECT array_agg(c.relname::text ORDER BY c.relname) AS tables
+             FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace
+            WHERE n.nspname=$1 AND c.relkind='r'`,
+          [appPublicPhysical]
+        )
+      ).rows[0].tables;
+      verify.domains = (
+        await client.query(
+          `SELECT array_agg(d.subdomain || '.' || d.domain ORDER BY d.subdomain) AS hosts
+             FROM services_public.domains d WHERE d.database_id=$1
+              AND (d.subdomain LIKE 'api-%' OR d.subdomain LIKE 'auth-%')`,
+          [dbId]
+        )
+      ).rows[0].hosts;
+
+      if (opts.dryRun) await client.query('ROLLBACK');
+      else await client.query('COMMIT');
+
+      return {
+        ok: true,
+        name,
+        subdomain,
+        dbId,
+        appPublicPhysical,
+        apiHost: `api-${subdomain}.${opts.domain}`,
+        authHost: `auth-${subdomain}.${opts.domain}`,
+        timings: t,
+        verify,
+        attempt,
+        rolledBack: opts.dryRun
+      };
+    } catch (err) {
+      try {
+        await client.query('ROLLBACK');
+      } catch {}
+      // 40P01/40001: deadlock/serialization. 57P01/08006/08003/53300 + message
+      // sniff: connection-class (e.g. PG crash recovery) — retry after a long
+      // backoff so the run survives a server restart.
+      const connLost =
+        ['57P01', '08006', '08003', '53300'].includes(err && err.code) ||
+        /connection terminated|terminating connection|server closed the connection/i.test(
+          (err && err.message) || ''
+        );
+      const retriable = connLost || (err && (err.code === '40P01' || err.code === '40001'));
+      if (retriable && attempt <= opts.maxRetries) {
+        const backoff = (connLost ? 10000 : 100) * attempt + Math.floor(Math.random() * 100);
+        console.error(`  [${name}] ${err.code} (attempt ${attempt}) — retrying in ${backoff}ms`);
+        await new Promise((r) => setTimeout(r, backoff));
+        continue;
+      }
+      return { ok: false, name, subdomain, error: err.message, code: err.code, attempt };
+    } finally {
+      client.release();
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// shape validation (step 3.i): compare the logical [schema,relname] set of a
+// tenant's `api` API to the reference tenant's — same set => same fingerprint =>
+// same bp: key. Mirrors graphql/server/src/middleware/blueprint.ts:
+// stripSchemaHashPrefix + fingerprintFromRelations.
+// ---------------------------------------------------------------------------
+const SHAPE_SQL = `
+  WITH api_schema AS (
+    SELECT s.schema_name
+      FROM metaschema_public.database d
+      JOIN services_public.apis a ON a.database_id = d.id AND a.name = 'api'
+      JOIN services_public.api_schemas x ON x.api_id = a.id
+      JOIN metaschema_public.schema s ON s.id = x.schema_id
+     WHERE d.name = $1
+  )
+  SELECT regexp_replace(n.nspname, '^.*?-[0-9a-f]{8}-', '') AS logical_schema, c.relname
+    FROM api_schema aps
+    JOIN pg_namespace n ON n.nspname = aps.schema_name
+    JOIN pg_class c ON c.relnamespace = n.oid AND c.relkind IN ('r','v','m','p')
+   ORDER BY 1, 2`;
+
+function sha256(str) {
+  return crypto.createHash('sha256').update(str).digest('hex');
+}
+
+async function shapeOf(pool, dbName) {
+  const r = await pool.query(SHAPE_SQL, [dbName]);
+  const pairs = r.rows.map((row) => [row.logical_schema, row.relname]);
+  // fingerprintFromRelations sorts then sha256(JSON.stringify(pairs))
+  pairs.sort((a, b) => (a[0] !== b[0] ? (a[0] < b[0] ? -1 : 1) : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0));
+  return { pairs, fingerprint: sha256(JSON.stringify(pairs)) };
+}
+
+async function validateShape(pool, opts) {
+  const ref = await shapeOf(pool, opts.reference);
+  const cand = await shapeOf(pool, opts.validate);
+  const same = ref.fingerprint === cand.fingerprint;
+  console.log(`\n=== SHAPE CHECK: "${opts.validate}" vs reference "${opts.reference}" ===`);
+  console.log(`reference api relations (${ref.pairs.length}):`);
+  for (const [s, r] of ref.pairs) console.log(`    ${s}.${r}`);
+  console.log(`candidate api relations (${cand.pairs.length}):`);
+  for (const [s, r] of cand.pairs) console.log(`    ${s}.${r}`);
+  console.log(`reference shapeFingerprint: ${ref.fingerprint}`);
+  console.log(`candidate shapeFingerprint: ${cand.fingerprint}`);
+  console.log(`IDENTICAL SHAPE => same bp: key expected: ${same ? 'YES' : 'NO'}`);
+  return same;
+}
+
+// ---------------------------------------------------------------------------
+// main
+// ---------------------------------------------------------------------------
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const pool = new Pool({ ...PG, max: Math.max(2, opts.concurrency + 1) });
+  // An idle pooled client dying (PG crash/restart) must not take down the run.
+  pool.on('error', (e) => console.error(`  [pool] idle client error (continuing): ${e.message}`));
+
+  try {
+    if (opts.validate) {
+      const ok = await validateShape(pool, opts);
+      process.exitCode = ok ? 0 : 1;
+      return;
+    }
+
+    const ref = await loadReference(pool, opts);
+    const start = opts.startIndex ?? (await nextStartIndex(pool, opts.prefix));
+    const indices = Array.from({ length: opts.count }, (_, k) => start + k);
+
+    console.log(
+      `tenant-factory: creating ${opts.count} tenant(s) prefix=${opts.prefix} indices=${start}..${
+        start + opts.count - 1
+      } blueprint=${opts.blueprint} concurrency=${opts.concurrency}${opts.dryRun ? ' [DRY-RUN]' : ''}`
+    );
+    console.log(
+      `  owner=${ref.ownerId} source-db=${ref.sourceDbId} modules=${ref.modules.length} items`
+    );
+
+    const results = [];
+    const wallStart = now();
+
+    // simple concurrency pool
+    let cursor = 0;
+    async function worker() {
+      for (;;) {
+        const i = cursor++;
+        if (i >= indices.length) return;
+        const idx = indices[i];
+        const tStart = now();
+        const res = await createTenant(pool, ref, opts, idx);
+        const wall = now() - tStart;
+        res.wall = wall;
+        results.push(res);
+        if (res.ok) {
+          const okTables =
+            Array.isArray(res.verify.appTables) && res.verify.appTables.length === 5;
+          console.log(
+            `  [${res.name}] OK db=${res.dbId} schemas=${res.verify.schemaCount} ` +
+              `appTables=${(res.verify.appTables || []).join(',')} ${okTables ? '✓' : '✗5'} ` +
+              `(prov ${ms(res.timings.provision)} boot ${ms(res.timings.bootstrap)} ` +
+              `bp ${ms(res.timings.blueprint)} wall ${ms(wall)}${
+                res.attempt > 1 ? ` retries=${res.attempt - 1}` : ''
+              })`
+          );
+        } else {
+          console.error(`  [${res.name}] FAILED code=${res.code} ${res.error}`);
+        }
+      }
+    }
+    await Promise.all(Array.from({ length: opts.concurrency }, () => worker()));
+
+    const wall = now() - wallStart;
+    const ok = results.filter((r) => r.ok);
+    const failed = results.filter((r) => !r.ok);
+    const totalSec = Number(wall) / 1e9;
+    const perMin = ok.length > 0 ? (ok.length / totalSec) * 60 : 0;
+
+    console.log(`\n=== SUMMARY ===`);
+    console.log(`created ${ok.length}/${opts.count} tenants in ${totalSec.toFixed(1)}s`);
+    if (ok.length) {
+      const avg = (sel) => ok.reduce((a, r) => a + Number(sel(r)), 0) / ok.length / 1e6;
+      console.log(
+        `  avg per-tenant: provision ${avg((r) => r.timings.provision).toFixed(0)}ms ` +
+          `bootstrap ${avg((r) => r.timings.bootstrap).toFixed(0)}ms ` +
+          `blueprint ${avg((r) => r.timings.blueprint).toFixed(0)}ms ` +
+          `wall ${avg((r) => r.wall).toFixed(0)}ms`
+      );
+      console.log(`  throughput: ${perMin.toFixed(2)} tenants/minute (concurrency=${opts.concurrency})`);
+      console.log(`  api hosts:`);
+      for (const r of ok) console.log(`    ${r.name}: ${r.apiHost}  (auth: ${r.authHost})`);
+    }
+    if (failed.length) {
+      console.log(`  FAILURES:`);
+      for (const r of failed) console.log(`    ${r.name}: [${r.code}] ${r.error}`);
+      process.exitCode = 1;
+    }
+  } finally {
+    await pool.end();
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/scripts/scale-validate/v2-ramps.mjs b/scripts/scale-validate/v2-ramps.mjs
new file mode 100644
index 0000000000..36f9b8fbfc
--- /dev/null
+++ b/scripts/scale-validate/v2-ramps.mjs
@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+// =============================================================================
+// v2-ramps.mjs — V2 limits-discovery executor.
+//
+// Runs a plan of ramp steps. Each step gets a FRESH server (clean cache, fresh
+// cumulative counters, own metrics file), then either:
+//   - drives the workload harness (harness.mjs) against a fleet manifest, or
+//   - fires a cold-burst: one concurrent first-hit per tenant in the manifest
+//     (use a 1-tenant-per-blueprint subset so every request is a cold build).
+//
+// Per step it records: harness latency/error summary, metrics-file maxima
+// (rss/heapUsed/buildQueueDepth), final cache+build counters, max PG backend
+// count during the run, and whether the server crashed (an 896MB-heap OOM is a
+// legitimate FINDING, not a script failure — steps continue).
+//
+// Usage:
+//   node scripts/scale-validate/v2-ramps.mjs --plan plans/v2-2048.json \
+//     [--out out/v2-2048-results.jsonl] [--only step1,step2]
+//
+// Plan file:
+//   { "port": 3345,
+//     "defaults": { "heapMb": 2048, "rps": 10, "durationSec": 420,
+//                   "shape": "uniform", "auth": 1, "mix": "read:0.7,write:0.25,meta:0.05" },
+//     "steps": [ { "name": "div-k3", "fleet": "out/fleet-k3.json" },
+//                { "name": "cold-burst", "fleet": "out/fleet-burst.json", "coldBurst": true } ] }
+//
+// Env: PGHOST PGPORT PGUSER PGPASSWORD PGDATABASE (defaults :5433 constructive)
+// =============================================================================
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { loadFleet, resolvePg, sleep } from './_lib.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKTREE = path.resolve(__dirname, '..', '..');
+const arg = (name, dflt) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > -1 ? process.argv[i + 1] : dflt;
+};
+
+const PLAN_FILE = path.resolve(__dirname, arg('plan', ''));
+const OUT = path.resolve(__dirname, arg('out', 'out/v2-results.jsonl'));
+const ONLY = (arg('only', '') || '').split(',').filter(Boolean);
+if (!PLAN_FILE || !fs.existsSync(PLAN_FILE)) {
+  console.error('--plan <file> is required');
+  process.exit(1);
+}
+const plan = JSON.parse(fs.readFileSync(PLAN_FILE, 'utf8'));
+const PORT = plan.port || 3345;
+const MB = (b) => Math.round((b / 1024 / 1024) * 10) / 10;
+
+const PG = {
+  host: process.env.PGHOST || 'localhost',
+  port: parseInt(process.env.PGPORT || '5433', 10),
+  user: process.env.PGUSER || 'postgres',
+  password: process.env.PGPASSWORD || 'password',
+  database: process.env.PGDATABASE || 'constructive'
+};
+
+// ---------------------------------------------------------------------------
+// server lifecycle
+// ---------------------------------------------------------------------------
+function waitForPort(port, timeoutMs) {
+  const hosts = ['127.0.0.1', '::1'];
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve, reject) => {
+    let i = 0;
+    const tryOnce = () => {
+      const sock = net.connect({ host: hosts[i++ % hosts.length], port }, () => {
+        sock.destroy();
+        resolve();
+      });
+      sock.on('error', () => {
+        sock.destroy();
+        if (Date.now() > deadline) reject(new Error(`port ${port} not listening after ${timeoutMs}ms`));
+        else setTimeout(tryOnce, 300);
+      });
+    };
+    tryOnce();
+  });
+}
+
+function readMetrics(file) {
+  if (!fs.existsSync(file)) return [];
+  return fs
+    .readFileSync(file, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function startServer({ heapMb, cacheMax, metricsFile, serverEnv }) {
+  const child = spawn(
+    'node',
+    ['packages/cli/dist/index.js', 'server', '--port', String(PORT), '--origin', '*', '--simpleInflection', '--postgis', '--servicesApi'],
+    {
+      cwd: WORKTREE,
+      env: {
+        ...process.env,
+        NODE_ENV: 'production',
+        NODE_OPTIONS: `--max-old-space-size=${heapMb}`,
+        GRAPHILE_DEBUG_METRICS: '1',
+        GRAPHILE_DEBUG_METRICS_FILE: metricsFile,
+        GRAPHILE_BLUEPRINT_POOLING: '1',
+        ...(cacheMax ? { GRAPHILE_CACHE_MAX: String(cacheMax) } : {}),
+        ...(serverEnv || {}),
+        PGHOST: PG.host,
+        PGPORT: String(PG.port),
+        PGUSER: PG.user,
+        PGPASSWORD: PG.password,
+        PGDATABASE: PG.database
+      },
+      stdio: ['ignore', 'pipe', 'pipe']
+    }
+  );
+  const state = { child, log: '', exited: false, exitCode: null, exitSignal: null };
+  child.stdout.on('data', (d) => (state.log = (state.log + d).slice(-8000)));
+  child.stderr.on('data', (d) => (state.log = (state.log + d).slice(-8000)));
+  child.on('exit', (code, signal) => {
+    state.exited = true;
+    state.exitCode = code;
+    state.exitSignal = signal;
+  });
+  return state;
+}
+
+async function stopServer(state) {
+  if (state.exited) return;
+  state.child.kill('SIGTERM');
+  const deadline = Date.now() + 15000;
+  while (!state.exited && Date.now() < deadline) await sleep(300);
+  if (!state.exited) {
+    state.child.kill('SIGKILL');
+    while (!state.exited) await sleep(200);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// pg backend sampling (server pools + LISTEN connections)
+// ---------------------------------------------------------------------------
+function startPgSampler() {
+  const { Client } = resolvePg();
+  const state = { max: 0, last: 0, samples: 0, stop: false, err: null, reconnects: 0 };
+  (async () => {
+    // PG may crash-recover mid-step (introspection OOM inside its cgroup) —
+    // swallow client errors and reconnect rather than killing the executor.
+    while (!state.stop) {
+      let client;
+      try {
+        client = new Client(PG);
+        client.on('error', () => {});
+        await client.connect();
+        while (!state.stop) {
+          const r = await client.query(
+            `SELECT count(*)::int AS c FROM pg_stat_activity
+              WHERE datname = current_database() AND pid <> pg_backend_pid()`
+          );
+          state.last = r.rows[0].c;
+          state.max = Math.max(state.max, state.last);
+          state.samples++;
+          await sleep(5000);
+        }
+      } catch (e) {
+        state.err = String(e && e.message ? e.message : e);
+        state.reconnects++;
+      } finally {
+        try {
+          await client?.end();
+        } catch {}
+      }
+      if (!state.stop) await sleep(5000);
+    }
+  })();
+  return state;
+}
+
+// ---------------------------------------------------------------------------
+// workloads
+// ---------------------------------------------------------------------------
+function runHarness(step, cfg, harnessOut) {
+  return new Promise((resolve) => {
+    const args = [
+      path.join(__dirname, 'harness.mjs'),
+      '--fleet', path.resolve(__dirname, step.fleet),
+      '--port', String(PORT),
+      '--duration-sec', String(cfg.durationSec),
+      '--rps', String(cfg.rps),
+      '--mix', cfg.mix,
+      '--shape', cfg.shape,
+      '--auth', String(cfg.auth),
+      '--sentinel-interval-sec', String(cfg.sentinelSec ?? 60),
+      '--seed', String(cfg.seed ?? 42),
+      '--out', harnessOut
+    ];
+    const child = spawn('node', args, { cwd: __dirname, stdio: ['ignore', 'pipe', 'pipe'] });
+    let tail = '';
+    child.stdout.on('data', (d) => {
+      process.stdout.write(d);
+      tail = (tail + d).slice(-4000);
+    });
+    child.stderr.on('data', (d) => {
+      process.stderr.write(d);
+      tail = (tail + d).slice(-4000);
+    });
+    child.on('exit', (code) => resolve({ code, tail }));
+  });
+}
+
+async function coldBurst(step, cfg) {
+  const { tenants } = loadFleet(path.resolve(__dirname, step.fleet));
+  const one = async (t) => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), cfg.coldTimeoutMs ?? 420000);
+    const start = performance.now();
+    try {
+      const res = await fetch(`http://${t.apiHost}:${PORT}/graphql`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ query: 'query { __typename }' }),
+        signal: ac.signal
+      });
+      await res.text();
+      return { dbname: t.dbname, status: res.status, ms: Math.round(performance.now() - start) };
+    } catch (e) {
+      return { dbname: t.dbname, status: 0, ms: Math.round(performance.now() - start), err: String(e).slice(0, 120) };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  console.log(`[cold-burst] firing ${tenants.length} concurrent first-hits...`);
+  const wave1 = await Promise.all(tenants.map(one));
+  const wave2 = await Promise.all(tenants.map(one)); // warm check
+  return { wave1, wave2 };
+}
+
+// ---------------------------------------------------------------------------
+// main
+// ---------------------------------------------------------------------------
+const main = async () => {
+  fs.mkdirSync(path.join(__dirname, 'out'), { recursive: true });
+  const steps = plan.steps.filter((s) => ONLY.length === 0 || ONLY.includes(s.name));
+  console.log(`[v2-ramps] plan=${path.basename(PLAN_FILE)} steps=${steps.map((s) => s.name).join(',')} port=${PORT}`);
+
+  for (const step of steps) {
+    const cfg = { ...plan.defaults, ...step };
+    const name = `${step.name}-h${cfg.heapMb}`;
+    const metricsFile = path.join(__dirname, 'out', `metrics-${name}.jsonl`);
+    const harnessOut = path.join(__dirname, 'out', `harness-${name}.json`);
+    if (fs.existsSync(metricsFile)) fs.rmSync(metricsFile);
+
+    console.log(`\n===== STEP ${name}: heap=${cfg.heapMb}MB fleet=${step.fleet} ${step.coldBurst ? 'COLD-BURST' : `rps=${cfg.rps} dur=${cfg.durationSec}s shape=${cfg.shape}`} =====`);
+    const record = { name: step.name, heapMb: cfg.heapMb, fleet: step.fleet, config: cfg, startedAt: new Date().toISOString() };
+    const server = startServer({ heapMb: cfg.heapMb, cacheMax: cfg.cacheMax, metricsFile, serverEnv: cfg.serverEnv });
+    const pgSampler = startPgSampler();
+    const t0 = Date.now();
+    try {
+      await waitForPort(PORT, 120000);
+      // metrics baseline so the sampler is known-alive before load
+      const bDeadline = Date.now() + 60000;
+      while (readMetrics(metricsFile).length < 1 && Date.now() < bDeadline) await sleep(2000);
+
+      if (step.coldBurst) {
+        record.coldBurst = await coldBurst(step, cfg);
+        const w1 = record.coldBurst.wave1;
+        record.summary = {
+          coldOk: w1.filter((r) => r.status === 200).length,
+          cold503: w1.filter((r) => r.status === 503).length,
+          coldErr: w1.filter((r) => r.status !== 200 && r.status !== 503).length,
+          coldMsMax: Math.max(...w1.map((r) => r.ms)),
+          warmMsMax: Math.max(...record.coldBurst.wave2.map((r) => r.ms))
+        };
+        await sleep(15000); // let the sampler catch the post-burst state
+      } else {
+        const h = await runHarness(step, cfg, harnessOut);
+        record.harnessExit = h.code; // 2 = bleed sentinel violation
+        if (fs.existsSync(harnessOut)) {
+          const rep = JSON.parse(fs.readFileSync(harnessOut, 'utf8'));
+          record.summary = {
+            achievedRps: rep.totals?.achievedRps,
+            completed: rep.totals?.completed,
+            errRate: rep.totals?.errRate,
+            latency: rep.latencyOverall,
+            readLatency: rep.byClass?.read?.latency,
+            http: rep.http,
+            netErrors: rep.netErrors,
+            sentinelOk: rep.sentinel?.ok,
+            verdict: rep.verdict
+          };
+        } else {
+          record.error = `harness produced no report (exit ${h.code})`;
+          record.harnessTail = h.tail;
+        }
+      }
+    } catch (e) {
+      record.error = String(e && e.message ? e.message : e);
+    } finally {
+      pgSampler.stop = true;
+      const crashed = server.exited;
+      const m = readMetrics(metricsFile);
+      if (m.length) {
+        const last = m[m.length - 1];
+        record.metrics = {
+          samples: m.length,
+          rssMaxMB: MB(Math.max(...m.map((x) => x.rss))),
+          heapUsedMaxMB: MB(Math.max(...m.map((x) => x.heapUsed))),
+          heapUsedLastMB: MB(last.heapUsed),
+          buildQueueDepthMax: Math.max(...m.map((x) => x.counters?.buildQueueDepth ?? 0)),
+          lastCache: last.cache,
+          lastCounters: last.counters
+        };
+      }
+      await stopServer(server);
+      if (crashed) {
+        record.serverCrashed = true;
+        record.serverExit = { code: server.exitCode, signal: server.exitSignal };
+        record.serverLogTail = server.log.slice(-2500);
+        console.error(`[v2-ramps] SERVER CRASHED during ${name}: code=${server.exitCode} signal=${server.exitSignal}`);
+      }
+      record.pgBackends = { max: pgSampler.max, samples: pgSampler.samples, err: pgSampler.err };
+      record.wallSec = Math.round((Date.now() - t0) / 1000);
+      record.endedAt = new Date().toISOString();
+      fs.appendFileSync(OUT, JSON.stringify(record) + '\n');
+      console.log(`[v2-ramps] step ${name} done in ${record.wallSec}s -> ${OUT}`);
+    }
+  }
+  console.log(`\n[v2-ramps] all steps complete -> ${OUT}`);
+};
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});