dunbar: v1

next/.pnp.loader.mjs

+import fs from 'fs';
+import { URL as URL$1, fileURLToPath, pathToFileURL } from 'url';
+import path from 'path';
+import { createHash } from 'crypto';
+import { EOL } from 'os';
+import moduleExports, { isBuiltin } from 'module';
+import assert from 'assert';
+
+const SAFE_TIME = 456789e3;
+
+const PortablePath = {
+  root: `/`,
+  dot: `.`,
+  parent: `..`
+};
+const npath = Object.create(path);
+const ppath = Object.create(path.posix);
+npath.cwd = () => process.cwd();
+ppath.cwd = process.platform === `win32` ? () => toPortablePath(process.cwd()) : process.cwd;
+if (process.platform === `win32`) {
+  ppath.resolve = (...segments) => {
+    if (segments.length > 0 && ppath.isAbsolute(segments[0])) {
+      return path.posix.resolve(...segments);
+    } else {
+      return path.posix.resolve(ppath.cwd(), ...segments);
+    }
+  };
+}
+const contains = function(pathUtils, from, to) {
+  from = pathUtils.normalize(from);
+  to = pathUtils.normalize(to);
+  if (from === to)
+    return `.`;
+  if (!from.endsWith(pathUtils.sep))
+    from = from + pathUtils.sep;
+  if (to.startsWith(from)) {
+    return to.slice(from.length);
+  } else {
+    return null;
+  }
+};
+npath.contains = (from, to) => contains(npath, from, to);
+ppath.contains = (from, to) => contains(ppath, from, to);
+const WINDOWS_PATH_REGEXP = /^([a-zA-Z]:.*)$/;
+const UNC_WINDOWS_PATH_REGEXP = /^\/\/(\.\/)?(.*)$/;
+const PORTABLE_PATH_REGEXP = /^\/([a-zA-Z]:.*)$/;
+const UNC_PORTABLE_PATH_REGEXP = /^\/unc\/(\.dot\/)?(.*)$/;
+function fromPortablePathWin32(p) {
+  let portablePathMatch, uncPortablePathMatch;
+  if (portablePathMatch = p.match(PORTABLE_PATH_REGEXP))
+    p = portablePathMatch[1];
+  else if (uncPortablePathMatch = p.match(UNC_PORTABLE_PATH_REGEXP))
+    p = `\\\\${uncPortablePathMatch[1] ? `.\\` : ``}${uncPortablePathMatch[2]}`;
+  else
+    return p;
+  return p.replace(/\//g, `\\`);
+}
+function toPortablePathWin32(p) {
+  p = p.replace(/\\/g, `/`);
+  let windowsPathMatch, uncWindowsPathMatch;
+  if (windowsPathMatch = p.match(WINDOWS_PATH_REGEXP))
+    p = `/${windowsPathMatch[1]}`;
+  else if (uncWindowsPathMatch = p.match(UNC_WINDOWS_PATH_REGEXP))
+    p = `/unc/${uncWindowsPathMatch[1] ? `.dot/` : ``}${uncWindowsPathMatch[2]}`;
+  return p;
+}
+const toPortablePath = process.platform === `win32` ? toPortablePathWin32 : (p) => p;
+const fromPortablePath = process.platform === `win32` ? fromPortablePathWin32 : (p) => p;
+npath.fromPortablePath = fromPortablePath;
+npath.toPortablePath = toPortablePath;
+function convertPath(targetPathUtils, sourcePath) {
+  return targetPathUtils === npath ? fromPortablePath(sourcePath) : toPortablePath(sourcePath);
+}
+
+const defaultTime = new Date(SAFE_TIME * 1e3);
+const defaultTimeMs = defaultTime.getTime();
+async function copyPromise(destinationFs, destination, sourceFs, source, opts) {
+  const normalizedDestination = destinationFs.pathUtils.normalize(destination);
+  const normalizedSource = sourceFs.pathUtils.normalize(source);
+  const prelayout = [];
+  const postlayout = [];
+  const { atime, mtime } = opts.stableTime ? { atime: defaultTime, mtime: defaultTime } : await sourceFs.lstatPromise(normalizedSource);
+  await destinationFs.mkdirpPromise(destinationFs.pathUtils.dirname(destination), { utimes: [atime, mtime] });
+  await copyImpl(prelayout, postlayout, destinationFs, normalizedDestination, sourceFs, normalizedSource, { ...opts, didParentExist: true });
+  for (const operation of prelayout)
+    await operation();
+  await Promise.all(postlayout.map((operation) => {
+    return operation();
+  }));
+}
+async function copyImpl(prelayout, postlayout, destinationFs, destination, sourceFs, source, opts) {
+  const destinationStat = opts.didParentExist ? await maybeLStat(destinationFs, destination) : null;
+  const sourceStat = await sourceFs.lstatPromise(source);
+  const { atime, mtime } = opts.stableTime ? { atime: defaultTime, mtime: defaultTime } : sourceStat;
+  let updated;
+  switch (true) {
+    case sourceStat.isDirectory():
+      {
+        updated = await copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+      }
+      break;
+    case sourceStat.isFile():
+      {
+        updated = await copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+      }
+      break;
+    case sourceStat.isSymbolicLink():
+      {
+        updated = await copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+      }
+      break;
+    default: {
+      throw new Error(`Unsupported file type (${sourceStat.mode})`);
+    }
+  }
+  if (opts.linkStrategy?.type !== `HardlinkFromIndex` || !sourceStat.isFile()) {
+    if (updated || destinationStat?.mtime?.getTime() !== mtime.getTime() || destinationStat?.atime?.getTime() !== atime.getTime()) {
+      postlayout.push(() => destinationFs.lutimesPromise(destination, atime, mtime));
+      updated = true;
+    }
+    if (destinationStat === null || (destinationStat.mode & 511) !== (sourceStat.mode & 511)) {
+      postlayout.push(() => destinationFs.chmodPromise(destination, sourceStat.mode & 511));
+      updated = true;
+    }
+  }
+  return updated;
+}
+async function maybeLStat(baseFs, p) {
+  try {
+    return await baseFs.lstatPromise(p);
+  } catch (e) {
+    return null;
+  }
+}
+async function copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+  if (destinationStat !== null && !destinationStat.isDirectory()) {
+    if (opts.overwrite) {
+      prelayout.push(async () => destinationFs.removePromise(destination));
+      destinationStat = null;
+    } else {
+      return false;
+    }
+  }
+  let updated = false;
+  if (destinationStat === null) {
+    prelayout.push(async () => {
+      try {
+        await destinationFs.mkdirPromise(destination, { mode: sourceStat.mode });
+      } catch (err) {
+        if (err.code !== `EEXIST`) {
+          throw err;
+        }
+      }
+    });
+    updated = true;
+  }
+  const entries = await sourceFs.readdirPromise(source);
+  const nextOpts = opts.didParentExist && !destinationStat ? { ...opts, didParentExist: false } : opts;
+  if (opts.stableSort) {
+    for (const entry of entries.sort()) {
+      if (await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts)) {
+        updated = true;
+      }
+    }
+  } else {
+    const entriesUpdateStatus = await Promise.all(entries.map(async (entry) => {
+      await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts);
+    }));
+    if (entriesUpdateStatus.some((status) => status)) {
+      updated = true;
+    }
+  }
+  return updated;
+}
+async function copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, linkStrategy) {
+  const sourceHash = await sourceFs.checksumFilePromise(source, { algorithm: `sha1` });
+  const defaultMode = 420;
+  const sourceMode = sourceStat.mode & 511;
+  const indexFileName = `${sourceHash}${sourceMode !== defaultMode ? sourceMode.toString(8) : ``}`;
+  const indexPath = destinationFs.pathUtils.join(linkStrategy.indexPath, sourceHash.slice(0, 2), `${indexFileName}.dat`);
+  let AtomicBehavior;
+  ((AtomicBehavior2) => {
+    AtomicBehavior2[AtomicBehavior2["Lock"] = 0] = "Lock";
+    AtomicBehavior2[AtomicBehavior2["Rename"] = 1] = "Rename";
+  })(AtomicBehavior || (AtomicBehavior = {}));
+  let atomicBehavior = 1 /* Rename */;
+  let indexStat = await maybeLStat(destinationFs, indexPath);
+  if (destinationStat) {
+    const isDestinationHardlinkedFromIndex = indexStat && destinationStat.dev === indexStat.dev && destinationStat.ino === indexStat.ino;
+    const isIndexModified = indexStat?.mtimeMs !== defaultTimeMs;
+    if (isDestinationHardlinkedFromIndex) {
+      if (isIndexModified && linkStrategy.autoRepair) {
+        atomicBehavior = 0 /* Lock */;
+        indexStat = null;
+      }
+    }
+    if (!isDestinationHardlinkedFromIndex) {
+      if (opts.overwrite) {
+        prelayout.push(async () => destinationFs.removePromise(destination));
+        destinationStat = null;
+      } else {
+        return false;
+      }
+    }
+  }
+  const tempPath = !indexStat && atomicBehavior === 1 /* Rename */ ? `${indexPath}.${Math.floor(Math.random() * 4294967296).toString(16).padStart(8, `0`)}` : null;
+  let tempPathCleaned = false;
+  prelayout.push(async () => {
+    if (!indexStat) {
+      if (atomicBehavior === 0 /* Lock */) {
+        await destinationFs.lockPromise(indexPath, async () => {
+          const content = await sourceFs.readFilePromise(source);
+          await destinationFs.writeFilePromise(indexPath, content);
+        });
+      }
+      if (atomicBehavior === 1 /* Rename */ && tempPath) {
+        const content = await sourceFs.readFilePromise(source);
+        await destinationFs.writeFilePromise(tempPath, content);
+        try {
+          await destinationFs.linkPromise(tempPath, indexPath);
+        } catch (err) {
+          if (err.code === `EEXIST`) {
+            tempPathCleaned = true;
+            await destinationFs.unlinkPromise(tempPath);
+          } else {
+            throw err;
+          }
+        }
+      }
+    }
+    if (!destinationStat) {
+      await destinationFs.linkPromise(indexPath, destination);
+    }
+  });
+  postlayout.push(async () => {
+    if (!indexStat) {
+      await destinationFs.lutimesPromise(indexPath, defaultTime, defaultTime);
+      if (sourceMode !== defaultMode) {
+        await destinationFs.chmodPromise(indexPath, sourceMode);
+      }
+    }
+    if (tempPath && !tempPathCleaned) {
+      await destinationFs.unlinkPromise(tempPath);
+    }
+  });
+  return false;
+}
+async function copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+  if (destinationStat !== null) {
+    if (opts.overwrite) {
+      prelayout.push(async () => destinationFs.removePromise(destination));
+      destinationStat = null;
+    } else {
+      return false;
+    }
+  }
+  prelayout.push(async () => {
+    const content = await sourceFs.readFilePromise(source);
+    await destinationFs.writeFilePromise(destination, content);
+  });
+  return true;
+}
+async function copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+  if (opts.linkStrategy?.type === `HardlinkFromIndex`) {
+    return copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, opts.linkStrategy);
+  } else {
+    return copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+  }
+}
+async function copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+  if (destinationStat !== null) {
+    if (opts.overwrite) {
+      prelayout.push(async () => destinationFs.removePromise(destination));
+      destinationStat = null;
+    } else {
+      return false;
+    }
+  }
+  prelayout.push(async () => {
+    await destinationFs.symlinkPromise(convertPath(destinationFs.pathUtils, await sourceFs.readlinkPromise(source)), destination);
+  });
+  return true;
+}
+
+class FakeFS {
+  constructor(pathUtils) {
+    this.pathUtils = pathUtils;
+  }
+  async *genTraversePromise(init, { stableSort = false } = {}) {
+    const stack = [init];
+    while (stack.length > 0) {
+      const p = stack.shift();
+      const entry = await this.lstatPromise(p);
+      if (entry.isDirectory()) {
+        const entries = await this.readdirPromise(p);
+        if (stableSort) {
+          for (const entry2 of entries.sort()) {
+            stack.push(this.pathUtils.join(p, entry2));
+          }
+        } else {
+          throw new Error(`Not supported`);
+        }
+      } else {
+        yield p;
+      }
+    }
+  }
+  async checksumFilePromise(path, { algorithm = `sha512` } = {}) {
+    const fd = await this.openPromise(path, `r`);
+    try {
+      const CHUNK_SIZE = 65536;
+      const chunk = Buffer.allocUnsafeSlow(CHUNK_SIZE);
+      const hash = createHash(algorithm);
+      let bytesRead = 0;
+      while ((bytesRead = await this.readPromise(fd, chunk, 0, CHUNK_SIZE)) !== 0)
+        hash.update(bytesRead === CHUNK_SIZE ? chunk : chunk.slice(0, bytesRead));
+      return hash.digest(`hex`);
+    } finally {
+      await this.closePromise(fd);
+    }
+  }
+  async removePromise(p, { recursive = true, maxRetries = 5 } = {}) {
+    let stat;
+    try {
+      stat = await this.lstatPromise(p);
+    } catch (error) {
+      if (error.code === `ENOENT`) {
+        return;
+      } else {
+        throw error;
+      }
+    }
+    if (stat.isDirectory()) {
+      if (recursive) {
+        const entries = await this.readdirPromise(p);
+        await Promise.all(entries.map((entry) => {
+          return this.removePromise(this.pathUtils.resolve(p, entry));
+        }));
+      }
+      for (let t = 0; t <= maxRetries; t++) {
+        try {
+          await this.rmdirPromise(p);
+          break;
+        } catch (error) {
+          if (error.code !== `EBUSY` && error.code !== `ENOTEMPTY`) {
+            throw error;
+          } else if (t < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, t * 100));
+          }
+        }
+      }
+    } else {
+      await this.unlinkPromise(p);
+    }
+  }
+  removeSync(p, { recursive = true } = {}) {
+    let stat;
+    try {
+      stat = this.lstatSync(p);
+    } catch (error) {
+      if (error.code === `ENOENT`) {
+        return;
+      } else {
+        throw error;
+      }
+    }
+    if (stat.isDirectory()) {
+      if (recursive)
+        for (const entry of this.readdirSync(p))
+          this.removeSync(this.pathUtils.resolve(p, entry));
+      this.rmdirSync(p);
+    } else {
+      this.unlinkSync(p);
+    }
+  }
+  async mkdirpPromise(p, { chmod, utimes } = {}) {
+    p = this.resolve(p);
+    if (p === this.pathUtils.dirname(p))
+      return void 0;
+    const parts = p.split(this.pathUtils.sep);
+    let createdDirectory;
+    for (let u = 2; u <= parts.length; ++u) {
+      const subPath = parts.slice(0, u).join(this.pathUtils.sep);
+      if (!this.existsSync(subPath)) {
+        try {
+          await this.mkdirPromise(subPath);
+        } catch (error) {
+          if (error.code === `EEXIST`) {
+            continue;
+          } else {
+            throw error;
+          }
+        }
+        createdDirectory ??= subPath;
+        if (chmod != null)
+          await this.chmodPromise(subPath, chmod);
+        if (utimes != null) {
+          await this.utimesPromise(subPath, utimes[0], utimes[1]);
+        } else {
+          const parentStat = await this.statPromise(this.pathUtils.dirname(subPath));
+          await this.utimesPromise(subPath, parentStat.atime, parentStat.mtime);
+        }
+      }
+    }
+    return createdDirectory;
+  }
+  mkdirpSync(p, { chmod, utimes } = {}) {
+    p = this.resolve(p);
+    if (p === this.pathUtils.dirname(p))
+      return void 0;
+    const parts = p.split(this.pathUtils.sep);
+    let createdDirectory;
+    for (let u = 2; u <= parts.length; ++u) {
+      const subPath = parts.slice(0, u).join(this.pathUtils.sep);
+      if (!this.existsSync(subPath)) {
+        try {
+          this.mkdirSync(subPath);
+        } catch (error) {
+          if (error.code === `EEXIST`) {
+            continue;
+          } else {
+            throw error;
+          }
+        }
+        createdDirectory ??= subPath;
+        if (chmod != null)
+          this.chmodSync(subPath, chmod);
+        if (utimes != null) {
+          this.utimesSync(subPath, utimes[0], utimes[1]);
+        } else {
+          const parentStat = this.statSync(this.pathUtils.dirname(subPath));
+          this.utimesSync(subPath, parentStat.atime, parentStat.mtime);
+        }
+      }
+    }
+    return createdDirectory;
+  }
+  async copyPromise(destination, source, { baseFs = this, overwrite = true, stableSort = false, stableTime = false, linkStrategy = null } = {}) {
+    return await copyPromise(this, destination, baseFs, source, { overwrite, stableSort, stableTime, linkStrategy });
+  }
+  copySync(destination, source, { baseFs = this, overwrite = true } = {}) {
+    const stat = baseFs.lstatSync(source);
+    const exists = this.existsSync(destination);
+    if (stat.isDirectory()) {
+      this.mkdirpSync(destination);
+      const directoryListing = baseFs.readdirSync(source);
+      for (const entry of directoryListing) {
+        this.copySync(this.pathUtils.join(destination, entry), baseFs.pathUtils.join(source, entry), { baseFs, overwrite });
+      }
+    } else if (stat.isFile()) {
+      if (!exists || overwrite) {
+        if (exists)
+          this.removeSync(destination);
+        const content = baseFs.readFileSync(source);
+        this.writeFileSync(destination, content);
+      }
+    } else if (stat.isSymbolicLink()) {
+      if (!exists || overwrite) {
+        if (exists)
+          this.removeSync(destination);
+        const target = baseFs.readlinkSync(source);
+        this.symlinkSync(convertPath(this.pathUtils, target), destination);
+      }
+    } else {
+      throw new Error(`Unsupported file type (file: ${source}, mode: 0o${stat.mode.toString(8).padStart(6, `0`)})`);
+    }
+    const mode = stat.mode & 511;
+    this.chmodSync(destination, mode);
+  }
+  async changeFilePromise(p, content, opts = {}) {
+    if (Buffer.isBuffer(content)) {
+      return this.changeFileBufferPromise(p, content, opts);
+    } else {
+      return this.changeFileTextPromise(p, content, opts);
+    }
+  }
+  async changeFileBufferPromise(p, content, { mode } = {}) {
+    let current = Buffer.alloc(0);
+    try {
+      current = await this.readFilePromise(p);
+    } catch (error) {
+    }
+    if (Buffer.compare(current, content) === 0)
+      return;
+    await this.writeFilePromise(p, content, { mode });
+  }
+  async changeFileTextPromise(p, content, { automaticNewlines, mode } = {}) {
+    let current = ``;
+    try {
+      current = await this.readFilePromise(p, `utf8`);
+    } catch (error) {
+    }
+    const normalizedContent = automaticNewlines ? normalizeLineEndings(current, content) : content;
+    if (current === normalizedContent)
+      return;
+    await this.writeFilePromise(p, normalizedContent, { mode });
+  }
+  changeFileSync(p, content, opts = {}) {
+    if (Buffer.isBuffer(content)) {
+      return this.changeFileBufferSync(p, content, opts);
+    } else {
+      return this.changeFileTextSync(p, content, opts);
+    }
+  }
+  changeFileBufferSync(p, content, { mode } = {}) {
+    let current = Buffer.alloc(0);
+    try {
+      current = this.readFileSync(p);
+    } catch (error) {
+    }
+    if (Buffer.compare(current, content) === 0)
+      return;
+    this.writeFileSync(p, content, { mode });
+  }
+  changeFileTextSync(p, content, { automaticNewlines = false, mode } = {}) {
+    let current = ``;
+    try {
+      current = this.readFileSync(p, `utf8`);
+    } catch (error) {
+    }
+    const normalizedContent = automaticNewlines ? normalizeLineEndings(current, content) : content;
+    if (current === normalizedContent)
+      return;
+    this.writeFileSync(p, normalizedContent, { mode });
+  }
+  async movePromise(fromP, toP) {
+    try {
+      await this.renamePromise(fromP, toP);
+    } catch (error) {
+      if (error.code === `EXDEV`) {
+        await this.copyPromise(toP, fromP);
+        await this.removePromise(fromP);
+      } else {
+        throw error;
+      }
+    }
+  }
+  moveSync(fromP, toP) {
+    try {
+      this.renameSync(fromP, toP);
+    } catch (error) {
+      if (error.code === `EXDEV`) {
+        this.copySync(toP, fromP);
+        this.removeSync(fromP);
+      } else {
+        throw error;
+      }
+    }
+  }
+  async lockPromise(affectedPath, callback) {
+    const lockPath = `${affectedPath}.flock`;
+    const interval = 1e3 / 60;
+    const startTime = Date.now();
+    let fd = null;
+    const isAlive = async () => {
+      let pid;
+      try {
+        [pid] = await this.readJsonPromise(lockPath);
+      } catch (error) {
+        return Date.now() - startTime < 500;
+      }
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    };
+    while (fd === null) {
+      try {
+        fd = await this.openPromise(lockPath, `wx`);
+      } catch (error) {
+        if (error.code === `EEXIST`) {
+          if (!await isAlive()) {
+            try {
+              await this.unlinkPromise(lockPath);
+              continue;
+            } catch (error2) {
+            }
+          }
+          if (Date.now() - startTime < 60 * 1e3) {
+            await new Promise((resolve) => setTimeout(resolve, interval));
+          } else {
+            throw new Error(`Couldn't acquire a lock in a reasonable time (via ${lockPath})`);
+          }
+        } else {
+          throw error;
+        }
+      }
+    }
+    await this.writePromise(fd, JSON.stringify([process.pid]));
+    try {
+      return await callback();
+    } finally {
+      try {
+        await this.closePromise(fd);
+        await this.unlinkPromise(lockPath);
+      } catch (error) {
+      }
+    }
+  }
+  async readJsonPromise(p) {
+    const content = await this.readFilePromise(p, `utf8`);
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      error.message += ` (in ${p})`;
+      throw error;
+    }
+  }
+  readJsonSync(p) {
+    const content = this.readFileSync(p, `utf8`);
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      error.message += ` (in ${p})`;
+      throw error;
+    }
+  }
+  async writeJsonPromise(p, data, { compact = false } = {}) {
+    const space = compact ? 0 : 2;
+    return await this.writeFilePromise(p, `${JSON.stringify(data, null, space)}
+`);
+  }
+  writeJsonSync(p, data, { compact = false } = {}) {
+    const space = compact ? 0 : 2;
+    return this.writeFileSync(p, `${JSON.stringify(data, null, space)}
+`);
+  }
+  async preserveTimePromise(p, cb) {
+    const stat = await this.lstatPromise(p);
+    const result = await cb();
+    if (typeof result !== `undefined`)
+      p = result;
+    await this.lutimesPromise(p, stat.atime, stat.mtime);
+  }
+  async preserveTimeSync(p, cb) {
+    const stat = this.lstatSync(p);
+    const result = cb();
+    if (typeof result !== `undefined`)
+      p = result;
+    this.lutimesSync(p, stat.atime, stat.mtime);
+  }
+}
+class BasePortableFakeFS extends FakeFS {
+  constructor() {
+    super(ppath);
+  }
+}
+function getEndOfLine(content) {
+  const matches = content.match(/\r?\n/g);
+  if (matches === null)
+    return EOL;
+  const crlf = matches.filter((nl) => nl === `\r
+`).length;
+  const lf = matches.length - crlf;
+  return crlf > lf ? `\r
+` : `
+`;
+}
+function normalizeLineEndings(originalContent, newContent) {
+  return newContent.replace(/\r?\n/g, getEndOfLine(originalContent));
+}
+
+class ProxiedFS extends FakeFS {
+  getExtractHint(hints) {
+    return this.baseFs.getExtractHint(hints);
+  }
+  resolve(path) {
+    return this.mapFromBase(this.baseFs.resolve(this.mapToBase(path)));
+  }
+  getRealPath() {
+    return this.mapFromBase(this.baseFs.getRealPath());
+  }
+  async openPromise(p, flags, mode) {
+    return this.baseFs.openPromise(this.mapToBase(p), flags, mode);
+  }
+  openSync(p, flags, mode) {
+    return this.baseFs.openSync(this.mapToBase(p), flags, mode);
+  }
+  async opendirPromise(p, opts) {
+    return Object.assign(await this.baseFs.opendirPromise(this.mapToBase(p), opts), { path: p });
+  }
+  opendirSync(p, opts) {
+    return Object.assign(this.baseFs.opendirSync(this.mapToBase(p), opts), { path: p });
+  }
+  async readPromise(fd, buffer, offset, length, position) {
+    return await this.baseFs.readPromise(fd, buffer, offset, length, position);
+  }
+  readSync(fd, buffer, offset, length, position) {
+    return this.baseFs.readSync(fd, buffer, offset, length, position);
+  }
+  async writePromise(fd, buffer, offset, length, position) {
+    if (typeof buffer === `string`) {
+      return await this.baseFs.writePromise(fd, buffer, offset);
+    } else {
+      return await this.baseFs.writePromise(fd, buffer, offset, length, position);
+    }
+  }
+  writeSync(fd, buffer, offset, length, position) {
+    if (typeof buffer === `string`) {
+      return this.baseFs.writeSync(fd, buffer, offset);
+    } else {
+      return this.baseFs.writeSync(fd, buffer, offset, length, position);
+    }
+  }
+  async closePromise(fd) {
+    return this.baseFs.closePromise(fd);
+  }
+  closeSync(fd) {
+    this.baseFs.closeSync(fd);
+  }
+  createReadStream(p, opts) {
+    return this.baseFs.createReadStream(p !== null ? this.mapToBase(p) : p, opts);
+  }
+  createWriteStream(p, opts) {
+    return this.baseFs.createWriteStream(p !== null ? this.mapToBase(p) : p, opts);
+  }
+  async realpathPromise(p) {
+    return this.mapFromBase(await this.baseFs.realpathPromise(this.mapToBase(p)));
+  }
+  realpathSync(p) {
+    return this.mapFromBase(this.baseFs.realpathSync(this.mapToBase(p)));
+  }
+  async existsPromise(p) {
+    return this.baseFs.existsPromise(this.mapToBase(p));
+  }
+  existsSync(p) {
+    return this.baseFs.existsSync(this.mapToBase(p));
+  }
+  accessSync(p, mode) {
+    return this.baseFs.accessSync(this.mapToBase(p), mode);
+  }
+  async accessPromise(p, mode) {
+    return this.baseFs.accessPromise(this.mapToBase(p), mode);
+  }
+  async statPromise(p, opts) {
+    return this.baseFs.statPromise(this.mapToBase(p), opts);
+  }
+  statSync(p, opts) {
+    return this.baseFs.statSync(this.mapToBase(p), opts);
+  }
+  async fstatPromise(fd, opts) {
+    return this.baseFs.fstatPromise(fd, opts);
+  }
+  fstatSync(fd, opts) {
+    return this.baseFs.fstatSync(fd, opts);
+  }
+  lstatPromise(p, opts) {
+    return this.baseFs.lstatPromise(this.mapToBase(p), opts);
+  }
+  lstatSync(p, opts) {
+    return this.baseFs.lstatSync(this.mapToBase(p), opts);
+  }
+  async fchmodPromise(fd, mask) {
+    return this.baseFs.fchmodPromise(fd, mask);
+  }
+  fchmodSync(fd, mask) {
+    return this.baseFs.fchmodSync(fd, mask);
+  }
+  async chmodPromise(p, mask) {
+    return this.baseFs.chmodPromise(this.mapToBase(p), mask);
+  }
+  chmodSync(p, mask) {
+    return this.baseFs.chmodSync(this.mapToBase(p), mask);
+  }
+  async fchownPromise(fd, uid, gid) {
+    return this.baseFs.fchownPromise(fd, uid, gid);
+  }
+  fchownSync(fd, uid, gid) {
+    return this.baseFs.fchownSync(fd, uid, gid);
+  }
+  async chownPromise(p, uid, gid) {
+    return this.baseFs.chownPromise(this.mapToBase(p), uid, gid);
+  }
+  chownSync(p, uid, gid) {
+    return this.baseFs.chownSync(this.mapToBase(p), uid, gid);
+  }
+  async renamePromise(oldP, newP) {
+    return this.baseFs.renamePromise(this.mapToBase(oldP), this.mapToBase(newP));
+  }
+  renameSync(oldP, newP) {
+    return this.baseFs.renameSync(this.mapToBase(oldP), this.mapToBase(newP));
+  }
+  async copyFilePromise(sourceP, destP, flags = 0) {
+    return this.baseFs.copyFilePromise(this.mapToBase(sourceP), this.mapToBase(destP), flags);
+  }
+  copyFileSync(sourceP, destP, flags = 0) {
+    return this.baseFs.copyFileSync(this.mapToBase(sourceP), this.mapToBase(destP), flags);
+  }
+  async appendFilePromise(p, content, opts) {
+    return this.baseFs.appendFilePromise(this.fsMapToBase(p), content, opts);
+  }
+  appendFileSync(p, content, opts) {
+    return this.baseFs.appendFileSync(this.fsMapToBase(p), content, opts);
+  }
+  async writeFilePromise(p, content, opts) {
+    return this.baseFs.writeFilePromise(this.fsMapToBase(p), content, opts);
+  }
+  writeFileSync(p, content, opts) {
+    return this.baseFs.writeFileSync(this.fsMapToBase(p), content, opts);
+  }
+  async unlinkPromise(p) {
+    return this.baseFs.unlinkPromise(this.mapToBase(p));
+  }
+  unlinkSync(p) {
+    return this.baseFs.unlinkSync(this.mapToBase(p));
+  }
+  async utimesPromise(p, atime, mtime) {
+    return this.baseFs.utimesPromise(this.mapToBase(p), atime, mtime);
+  }
+  utimesSync(p, atime, mtime) {
+    return this.baseFs.utimesSync(this.mapToBase(p), atime, mtime);
+  }
+  async lutimesPromise(p, atime, mtime) {
+    return this.baseFs.lutimesPromise(this.mapToBase(p), atime, mtime);
+  }
+  lutimesSync(p, atime, mtime) {
+    return this.baseFs.lutimesSync(this.mapToBase(p), atime, mtime);
+  }
+  async mkdirPromise(p, opts) {
+    return this.baseFs.mkdirPromise(this.mapToBase(p), opts);
+  }
+  mkdirSync(p, opts) {
+    return this.baseFs.mkdirSync(this.mapToBase(p), opts);
+  }
+  async rmdirPromise(p, opts) {
+    return this.baseFs.rmdirPromise(this.mapToBase(p), opts);
+  }
+  rmdirSync(p, opts) {
+    return this.baseFs.rmdirSync(this.mapToBase(p), opts);
+  }
+  async linkPromise(existingP, newP) {
+    return this.baseFs.linkPromise(this.mapToBase(existingP), this.mapToBase(newP));
+  }
+  linkSync(existingP, newP) {
+    return this.baseFs.linkSync(this.mapToBase(existingP), this.mapToBase(newP));
+  }
+  async symlinkPromise(target, p, type) {
+    const mappedP = this.mapToBase(p);
+    if (this.pathUtils.isAbsolute(target))
+      return this.baseFs.symlinkPromise(this.mapToBase(target), mappedP, type);
+    const mappedAbsoluteTarget = this.mapToBase(this.pathUtils.join(this.pathUtils.dirname(p), target));
+    const mappedTarget = this.baseFs.pathUtils.relative(this.baseFs.pathUtils.dirname(mappedP), mappedAbsoluteTarget);
+    return this.baseFs.symlinkPromise(mappedTarget, mappedP, type);
+  }
+  symlinkSync(target, p, type) {
+    const mappedP = this.mapToBase(p);
+    if (this.pathUtils.isAbsolute(target))
+      return this.baseFs.symlinkSync(this.mapToBase(target), mappedP, type);
+    const mappedAbsoluteTarget = this.mapToBase(this.pathUtils.join(this.pathUtils.dirname(p), target));
+    const mappedTarget = this.baseFs.pathUtils.relative(this.baseFs.pathUtils.dirname(mappedP), mappedAbsoluteTarget);
+    return this.baseFs.symlinkSync(mappedTarget, mappedP, type);
+  }
+  async readFilePromise(p, encoding) {
+    return this.baseFs.readFilePromise(this.fsMapToBase(p), encoding);
+  }
+  readFileSync(p, encoding) {
+    return this.baseFs.readFileSync(this.fsMapToBase(p), encoding);
+  }
+  readdirPromise(p, opts) {
+    return this.baseFs.readdirPromise(this.mapToBase(p), opts);
+  }
+  readdirSync(p, opts) {
+    return this.baseFs.readdirSync(this.mapToBase(p), opts);
+  }
+  async readlinkPromise(p) {
+    return this.mapFromBase(await this.baseFs.readlinkPromise(this.mapToBase(p)));
+  }
+  readlinkSync(p) {
+    return this.mapFromBase(this.baseFs.readlinkSync(this.mapToBase(p)));
+  }
+  async truncatePromise(p, len) {
+    return this.baseFs.truncatePromise(this.mapToBase(p), len);
+  }
+  truncateSync(p, len) {
+    return this.baseFs.truncateSync(this.mapToBase(p), len);
+  }
+  async ftruncatePromise(fd, len) {
+    return this.baseFs.ftruncatePromise(fd, len);
+  }
+  ftruncateSync(fd, len) {
+    return this.baseFs.ftruncateSync(fd, len);
+  }
+  watch(p, a, b) {
+    return this.baseFs.watch(
+      this.mapToBase(p),
+      a,
+      b
+    );
+  }
+  watchFile(p, a, b) {
+    return this.baseFs.watchFile(
+      this.mapToBase(p),
+      a,
+      b
+    );
+  }
+  unwatchFile(p, cb) {
+    return this.baseFs.unwatchFile(this.mapToBase(p), cb);
+  }
+  fsMapToBase(p) {
+    if (typeof p === `number`) {
+      return p;
+    } else {
+      return this.mapToBase(p);
+    }
+  }
+}
+
+function direntToPortable(dirent) {
+  const portableDirent = dirent;
+  if (typeof dirent.path === `string`)
+    portableDirent.path = npath.toPortablePath(dirent.path);
+  return portableDirent;
+}
+class NodeFS extends BasePortableFakeFS {
+  constructor(realFs = fs) {
+    super();
+    this.realFs = realFs;
+  }
+  getExtractHint() {
+    return false;
+  }
+  getRealPath() {
+    return PortablePath.root;
+  }
+  resolve(p) {
+    return ppath.resolve(p);
+  }
+  async openPromise(p, flags, mode) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.open(npath.fromPortablePath(p), flags, mode, this.makeCallback(resolve, reject));
+    });
+  }
+  openSync(p, flags, mode) {
+    return this.realFs.openSync(npath.fromPortablePath(p), flags, mode);
+  }
+  async opendirPromise(p, opts) {
+    return await new Promise((resolve, reject) => {
+      if (typeof opts !== `undefined`) {
+        this.realFs.opendir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.opendir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+      }
+    }).then((dir) => {
+      const dirWithFixedPath = dir;
+      Object.defineProperty(dirWithFixedPath, `path`, {
+        value: p,
+        configurable: true,
+        writable: true
+      });
+      return dirWithFixedPath;
+    });
+  }
+  opendirSync(p, opts) {
+    const dir = typeof opts !== `undefined` ? this.realFs.opendirSync(npath.fromPortablePath(p), opts) : this.realFs.opendirSync(npath.fromPortablePath(p));
+    const dirWithFixedPath = dir;
+    Object.defineProperty(dirWithFixedPath, `path`, {
+      value: p,
+      configurable: true,
+      writable: true
+    });
+    return dirWithFixedPath;
+  }
+  async readPromise(fd, buffer, offset = 0, length = 0, position = -1) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.read(fd, buffer, offset, length, position, (error, bytesRead) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(bytesRead);
+        }
+      });
+    });
+  }
+  readSync(fd, buffer, offset, length, position) {
+    return this.realFs.readSync(fd, buffer, offset, length, position);
+  }
+  async writePromise(fd, buffer, offset, length, position) {
+    return await new Promise((resolve, reject) => {
+      if (typeof buffer === `string`) {
+        return this.realFs.write(fd, buffer, offset, this.makeCallback(resolve, reject));
+      } else {
+        return this.realFs.write(fd, buffer, offset, length, position, this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  writeSync(fd, buffer, offset, length, position) {
+    if (typeof buffer === `string`) {
+      return this.realFs.writeSync(fd, buffer, offset);
+    } else {
+      return this.realFs.writeSync(fd, buffer, offset, length, position);
+    }
+  }
+  async closePromise(fd) {
+    await new Promise((resolve, reject) => {
+      this.realFs.close(fd, this.makeCallback(resolve, reject));
+    });
+  }
+  closeSync(fd) {
+    this.realFs.closeSync(fd);
+  }
+  createReadStream(p, opts) {
+    const realPath = p !== null ? npath.fromPortablePath(p) : p;
+    return this.realFs.createReadStream(realPath, opts);
+  }
+  createWriteStream(p, opts) {
+    const realPath = p !== null ? npath.fromPortablePath(p) : p;
+    return this.realFs.createWriteStream(realPath, opts);
+  }
+  async realpathPromise(p) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.realpath(npath.fromPortablePath(p), {}, this.makeCallback(resolve, reject));
+    }).then((path) => {
+      return npath.toPortablePath(path);
+    });
+  }
+  realpathSync(p) {
+    return npath.toPortablePath(this.realFs.realpathSync(npath.fromPortablePath(p), {}));
+  }
+  async existsPromise(p) {
+    return await new Promise((resolve) => {
+      this.realFs.exists(npath.fromPortablePath(p), resolve);
+    });
+  }
+  accessSync(p, mode) {
+    return this.realFs.accessSync(npath.fromPortablePath(p), mode);
+  }
+  async accessPromise(p, mode) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.access(npath.fromPortablePath(p), mode, this.makeCallback(resolve, reject));
+    });
+  }
+  existsSync(p) {
+    return this.realFs.existsSync(npath.fromPortablePath(p));
+  }
+  async statPromise(p, opts) {
+    return await new Promise((resolve, reject) => {
+      if (opts) {
+        this.realFs.stat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.stat(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  statSync(p, opts) {
+    if (opts) {
+      return this.realFs.statSync(npath.fromPortablePath(p), opts);
+    } else {
+      return this.realFs.statSync(npath.fromPortablePath(p));
+    }
+  }
+  async fstatPromise(fd, opts) {
+    return await new Promise((resolve, reject) => {
+      if (opts) {
+        this.realFs.fstat(fd, opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.fstat(fd, this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  fstatSync(fd, opts) {
+    if (opts) {
+      return this.realFs.fstatSync(fd, opts);
+    } else {
+      return this.realFs.fstatSync(fd);
+    }
+  }
+  async lstatPromise(p, opts) {
+    return await new Promise((resolve, reject) => {
+      if (opts) {
+        this.realFs.lstat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.lstat(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  lstatSync(p, opts) {
+    if (opts) {
+      return this.realFs.lstatSync(npath.fromPortablePath(p), opts);
+    } else {
+      return this.realFs.lstatSync(npath.fromPortablePath(p));
+    }
+  }
+  async fchmodPromise(fd, mask) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.fchmod(fd, mask, this.makeCallback(resolve, reject));
+    });
+  }
+  fchmodSync(fd, mask) {
+    return this.realFs.fchmodSync(fd, mask);
+  }
+  async chmodPromise(p, mask) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.chmod(npath.fromPortablePath(p), mask, this.makeCallback(resolve, reject));
+    });
+  }
+  chmodSync(p, mask) {
+    return this.realFs.chmodSync(npath.fromPortablePath(p), mask);
+  }
+  async fchownPromise(fd, uid, gid) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.fchown(fd, uid, gid, this.makeCallback(resolve, reject));
+    });
+  }
+  fchownSync(fd, uid, gid) {
+    return this.realFs.fchownSync(fd, uid, gid);
+  }
+  async chownPromise(p, uid, gid) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.chown(npath.fromPortablePath(p), uid, gid, this.makeCallback(resolve, reject));
+    });
+  }
+  chownSync(p, uid, gid) {
+    return this.realFs.chownSync(npath.fromPortablePath(p), uid, gid);
+  }
+  async renamePromise(oldP, newP) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.rename(npath.fromPortablePath(oldP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject));
+    });
+  }
+  renameSync(oldP, newP) {
+    return this.realFs.renameSync(npath.fromPortablePath(oldP), npath.fromPortablePath(newP));
+  }
+  async copyFilePromise(sourceP, destP, flags = 0) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.copyFile(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags, this.makeCallback(resolve, reject));
+    });
+  }
+  copyFileSync(sourceP, destP, flags = 0) {
+    return this.realFs.copyFileSync(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags);
+  }
+  async appendFilePromise(p, content, opts) {
+    return await new Promise((resolve, reject) => {
+      const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
+      if (opts) {
+        this.realFs.appendFile(fsNativePath, content, opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.appendFile(fsNativePath, content, this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  appendFileSync(p, content, opts) {
+    const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
+    if (opts) {
+      this.realFs.appendFileSync(fsNativePath, content, opts);
+    } else {
+      this.realFs.appendFileSync(fsNativePath, content);
+    }
+  }
+  async writeFilePromise(p, content, opts) {
+    return await new Promise((resolve, reject) => {
+      const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
+      if (opts) {
+        this.realFs.writeFile(fsNativePath, content, opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.writeFile(fsNativePath, content, this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  writeFileSync(p, content, opts) {
+    const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
+    if (opts) {
+      this.realFs.writeFileSync(fsNativePath, content, opts);
+    } else {
+      this.realFs.writeFileSync(fsNativePath, content);
+    }
+  }
+  async unlinkPromise(p) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.unlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+    });
+  }
+  unlinkSync(p) {
+    return this.realFs.unlinkSync(npath.fromPortablePath(p));
+  }
+  async utimesPromise(p, atime, mtime) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.utimes(npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject));
+    });
+  }
+  utimesSync(p, atime, mtime) {
+    this.realFs.utimesSync(npath.fromPortablePath(p), atime, mtime);
+  }
+  async lutimesPromise(p, atime, mtime) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.lutimes(npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject));
+    });
+  }
+  lutimesSync(p, atime, mtime) {
+    this.realFs.lutimesSync(npath.fromPortablePath(p), atime, mtime);
+  }
+  async mkdirPromise(p, opts) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.mkdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
+    });
+  }
+  mkdirSync(p, opts) {
+    return this.realFs.mkdirSync(npath.fromPortablePath(p), opts);
+  }
+  async rmdirPromise(p, opts) {
+    return await new Promise((resolve, reject) => {
+      if (opts) {
+        this.realFs.rmdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
+      } else {
+        this.realFs.rmdir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  rmdirSync(p, opts) {
+    return this.realFs.rmdirSync(npath.fromPortablePath(p), opts);
+  }
+  async linkPromise(existingP, newP) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.link(npath.fromPortablePath(existingP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject));
+    });
+  }
+  linkSync(existingP, newP) {
+    return this.realFs.linkSync(npath.fromPortablePath(existingP), npath.fromPortablePath(newP));
+  }
+  async symlinkPromise(target, p, type) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.symlink(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type, this.makeCallback(resolve, reject));
+    });
+  }
+  symlinkSync(target, p, type) {
+    return this.realFs.symlinkSync(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type);
+  }
+  async readFilePromise(p, encoding) {
+    return await new Promise((resolve, reject) => {
+      const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
+      this.realFs.readFile(fsNativePath, encoding, this.makeCallback(resolve, reject));
+    });
+  }
+  readFileSync(p, encoding) {
+    const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
+    return this.realFs.readFileSync(fsNativePath, encoding);
+  }
+  async readdirPromise(p, opts) {
+    return await new Promise((resolve, reject) => {
+      if (opts) {
+        if (opts.recursive && process.platform === `win32`) {
+          if (opts.withFileTypes) {
+            this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback((results) => resolve(results.map(direntToPortable)), reject));
+          } else {
+            this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback((results) => resolve(results.map(npath.toPortablePath)), reject));
+          }
+        } else {
+          this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
+        }
+      } else {
+        this.realFs.readdir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+      }
+    });
+  }
+  readdirSync(p, opts) {
+    if (opts) {
+      if (opts.recursive && process.platform === `win32`) {
+        if (opts.withFileTypes) {
+          return this.realFs.readdirSync(npath.fromPortablePath(p), opts).map(direntToPortable);
+        } else {
+          return this.realFs.readdirSync(npath.fromPortablePath(p), opts).map(npath.toPortablePath);
+        }
+      } else {
+        return this.realFs.readdirSync(npath.fromPortablePath(p), opts);
+      }
+    } else {
+      return this.realFs.readdirSync(npath.fromPortablePath(p));
+    }
+  }
+  async readlinkPromise(p) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.readlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
+    }).then((path) => {
+      return npath.toPortablePath(path);
+    });
+  }
+  readlinkSync(p) {
+    return npath.toPortablePath(this.realFs.readlinkSync(npath.fromPortablePath(p)));
+  }
+  async truncatePromise(p, len) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.truncate(npath.fromPortablePath(p), len, this.makeCallback(resolve, reject));
+    });
+  }
+  truncateSync(p, len) {
+    return this.realFs.truncateSync(npath.fromPortablePath(p), len);
+  }
+  async ftruncatePromise(fd, len) {
+    return await new Promise((resolve, reject) => {
+      this.realFs.ftruncate(fd, len, this.makeCallback(resolve, reject));
+    });
+  }
+  ftruncateSync(fd, len) {
+    return this.realFs.ftruncateSync(fd, len);
+  }
+  watch(p, a, b) {
+    return this.realFs.watch(
+      npath.fromPortablePath(p),
+      a,
+      b
+    );
+  }
+  watchFile(p, a, b) {
+    return this.realFs.watchFile(
+      npath.fromPortablePath(p),
+      a,
+      b
+    );
+  }
+  unwatchFile(p, cb) {
+    return this.realFs.unwatchFile(npath.fromPortablePath(p), cb);
+  }
+  makeCallback(resolve, reject) {
+    return (err, result) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(result);
+      }
+    };
+  }
+}
+
+const NUMBER_REGEXP = /^[0-9]+$/;
+const VIRTUAL_REGEXP = /^(\/(?:[^/]+\/)*?(?:\$\$virtual|__virtual__))((?:\/((?:[^/]+-)?[a-f0-9]+)(?:\/([^/]+))?)?((?:\/.*)?))$/;
+const VALID_COMPONENT = /^([^/]+-)?[a-f0-9]+$/;
+class VirtualFS extends ProxiedFS {
+  constructor({ baseFs = new NodeFS() } = {}) {
+    super(ppath);
+    this.baseFs = baseFs;
+  }
+  static makeVirtualPath(base, component, to) {
+    if (ppath.basename(base) !== `__virtual__`)
+      throw new Error(`Assertion failed: Virtual folders must be named "__virtual__"`);
+    if (!ppath.basename(component).match(VALID_COMPONENT))
+      throw new Error(`Assertion failed: Virtual components must be ended by an hexadecimal hash`);
+    const target = ppath.relative(ppath.dirname(base), to);
+    const segments = target.split(`/`);
+    let depth = 0;
+    while (depth < segments.length && segments[depth] === `..`)
+      depth += 1;
+    const finalSegments = segments.slice(depth);
+    const fullVirtualPath = ppath.join(base, component, String(depth), ...finalSegments);
+    return fullVirtualPath;
+  }
+  static resolveVirtual(p) {
+    const match = p.match(VIRTUAL_REGEXP);
+    if (!match || !match[3] && match[5])
+      return p;
+    const target = ppath.dirname(match[1]);
+    if (!match[3] || !match[4])
+      return target;
+    const isnum = NUMBER_REGEXP.test(match[4]);
+    if (!isnum)
+      return p;
+    const depth = Number(match[4]);
+    const backstep = `../`.repeat(depth);
+    const subpath = match[5] || `.`;
+    return VirtualFS.resolveVirtual(ppath.join(target, backstep, subpath));
+  }
+  getExtractHint(hints) {
+    return this.baseFs.getExtractHint(hints);
+  }
+  getRealPath() {
+    return this.baseFs.getRealPath();
+  }
+  realpathSync(p) {
+    const match = p.match(VIRTUAL_REGEXP);
+    if (!match)
+      return this.baseFs.realpathSync(p);
+    if (!match[5])
+      return p;
+    const realpath = this.baseFs.realpathSync(this.mapToBase(p));
+    return VirtualFS.makeVirtualPath(match[1], match[3], realpath);
+  }
+  async realpathPromise(p) {
+    const match = p.match(VIRTUAL_REGEXP);
+    if (!match)
+      return await this.baseFs.realpathPromise(p);
+    if (!match[5])
+      return p;
+    const realpath = await this.baseFs.realpathPromise(this.mapToBase(p));
+    return VirtualFS.makeVirtualPath(match[1], match[3], realpath);
+  }
+  mapToBase(p) {
+    if (p === ``)
+      return p;
+    if (this.pathUtils.isAbsolute(p))
+      return VirtualFS.resolveVirtual(p);
+    const resolvedRoot = VirtualFS.resolveVirtual(this.baseFs.resolve(PortablePath.dot));
+    const resolvedP = VirtualFS.resolveVirtual(this.baseFs.resolve(p));
+    return ppath.relative(resolvedRoot, resolvedP) || PortablePath.dot;
+  }
+  mapFromBase(p) {
+    return p;
+  }
+}
+
+const URL = Number(process.versions.node.split('.', 1)[0]) < 20 ? URL$1 : globalThis.URL;
+
+const [major, minor] = process.versions.node.split(`.`).map((value) => parseInt(value, 10));
+const WATCH_MODE_MESSAGE_USES_ARRAYS = major > 19 || major === 19 && minor >= 2 || major === 18 && minor >= 13;
+const HAS_LAZY_LOADED_TRANSLATORS = major === 20 && minor < 6 || major === 19 && minor >= 3;
+
+function readPackageScope(checkPath) {
+  const rootSeparatorIndex = checkPath.indexOf(npath.sep);
+  let separatorIndex;
+  do {
+    separatorIndex = checkPath.lastIndexOf(npath.sep);
+    checkPath = checkPath.slice(0, separatorIndex);
+    if (checkPath.endsWith(`${npath.sep}node_modules`))
+      return false;
+    const pjson = readPackage(checkPath + npath.sep);
+    if (pjson) {
+      return {
+        data: pjson,
+        path: checkPath
+      };
+    }
+  } while (separatorIndex > rootSeparatorIndex);
+  return false;
+}
+function readPackage(requestPath) {
+  const jsonPath = npath.resolve(requestPath, `package.json`);
+  if (!fs.existsSync(jsonPath))
+    return null;
+  return JSON.parse(fs.readFileSync(jsonPath, `utf8`));
+}
+
+async function tryReadFile$1(path2) {
+  try {
+    return await fs.promises.readFile(path2, `utf8`);
+  } catch (error) {
+    if (error.code === `ENOENT`)
+      return null;
+    throw error;
+  }
+}
+function tryParseURL(str, base) {
+  try {
+    return new URL(str, base);
+  } catch {
+    return null;
+  }
+}
+let entrypointPath = null;
+function setEntrypointPath(file) {
+  entrypointPath = file;
+}
+function getFileFormat(filepath) {
+  const ext = path.extname(filepath);
+  switch (ext) {
+    case `.mjs`: {
+      return `module`;
+    }
+    case `.cjs`: {
+      return `commonjs`;
+    }
+    case `.wasm`: {
+      throw new Error(
+        `Unknown file extension ".wasm" for ${filepath}`
+      );
+    }
+    case `.json`: {
+      return `json`;
+    }
+    case `.js`: {
+      const pkg = readPackageScope(filepath);
+      if (!pkg)
+        return `commonjs`;
+      return pkg.data.type ?? `commonjs`;
+    }
+    default: {
+      if (entrypointPath !== filepath)
+        return null;
+      const pkg = readPackageScope(filepath);
+      if (!pkg)
+        return `commonjs`;
+      if (pkg.data.type === `module`)
+        return null;
+      return pkg.data.type ?? `commonjs`;
+    }
+  }
+}
+
+async function load$1(urlString, context, nextLoad) {
+  const url = tryParseURL(urlString);
+  if (url?.protocol !== `file:`)
+    return nextLoad(urlString, context, nextLoad);
+  const filePath = fileURLToPath(url);
+  const format = getFileFormat(filePath);
+  if (!format)
+    return nextLoad(urlString, context, nextLoad);
+  if (format === `json` && context.importAssertions?.type !== `json`) {
+    const err = new TypeError(`[ERR_IMPORT_ASSERTION_TYPE_MISSING]: Module "${urlString}" needs an import assertion of type "json"`);
+    err.code = `ERR_IMPORT_ASSERTION_TYPE_MISSING`;
+    throw err;
+  }
+  if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
+    const pathToSend = pathToFileURL(
+      npath.fromPortablePath(
+        VirtualFS.resolveVirtual(npath.toPortablePath(filePath))
+      )
+    ).href;
+    process.send({
+      "watch:import": WATCH_MODE_MESSAGE_USES_ARRAYS ? [pathToSend] : pathToSend
+    });
+  }
+  return {
+    format,
+    source: format === `commonjs` ? void 0 : await fs.promises.readFile(filePath, `utf8`),
+    shortCircuit: true
+  };
+}
+
+const ArrayIsArray = Array.isArray;
+const JSONStringify = JSON.stringify;
+const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
+const ObjectPrototypeHasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+const RegExpPrototypeExec = (obj, string) => RegExp.prototype.exec.call(obj, string);
+const RegExpPrototypeSymbolReplace = (obj, ...rest) => RegExp.prototype[Symbol.replace].apply(obj, rest);
+const StringPrototypeEndsWith = (str, ...rest) => String.prototype.endsWith.apply(str, rest);
+const StringPrototypeIncludes = (str, ...rest) => String.prototype.includes.apply(str, rest);
+const StringPrototypeLastIndexOf = (str, ...rest) => String.prototype.lastIndexOf.apply(str, rest);
+const StringPrototypeIndexOf = (str, ...rest) => String.prototype.indexOf.apply(str, rest);
+const StringPrototypeReplace = (str, ...rest) => String.prototype.replace.apply(str, rest);
+const StringPrototypeSlice = (str, ...rest) => String.prototype.slice.apply(str, rest);
+const StringPrototypeStartsWith = (str, ...rest) => String.prototype.startsWith.apply(str, rest);
+const SafeMap = Map;
+const JSONParse = JSON.parse;
+
+function createErrorType(code, messageCreator, errorType) {
+  return class extends errorType {
+    constructor(...args) {
+      super(messageCreator(...args));
+      this.code = code;
+      this.name = `${errorType.name} [${code}]`;
+    }
+  };
+}
+const ERR_PACKAGE_IMPORT_NOT_DEFINED = createErrorType(
+  `ERR_PACKAGE_IMPORT_NOT_DEFINED`,
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ``} imported from ${base}`;
+  },
+  TypeError
+);
+const ERR_INVALID_MODULE_SPECIFIER = createErrorType(
+  `ERR_INVALID_MODULE_SPECIFIER`,
+  (request, reason, base = void 0) => {
+    return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ``}`;
+  },
+  TypeError
+);
+const ERR_INVALID_PACKAGE_TARGET = createErrorType(
+  `ERR_INVALID_PACKAGE_TARGET`,
+  (pkgPath, key, target, isImport = false, base = void 0) => {
+    const relError = typeof target === `string` && !isImport && target.length && !StringPrototypeStartsWith(target, `./`);
+    if (key === `.`) {
+      assert(isImport === false);
+      return `Invalid "exports" main target ${JSONStringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`;
+    }
+    return `Invalid "${isImport ? `imports` : `exports`}" target ${JSONStringify(
+      target
+    )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`;
+  },
+  Error
+);
+const ERR_INVALID_PACKAGE_CONFIG = createErrorType(
+  `ERR_INVALID_PACKAGE_CONFIG`,
+  (path, base, message) => {
+    return `Invalid package config ${path}${base ? ` while importing ${base}` : ``}${message ? `. ${message}` : ``}`;
+  },
+  Error
+);
+
+function filterOwnProperties(source, keys) {
+  const filtered = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (ObjectPrototypeHasOwnProperty(source, key)) {
+      filtered[key] = source[key];
+    }
+  }
+  return filtered;
+}
+
+const packageJSONCache = new SafeMap();
+function getPackageConfig(path, specifier, base, readFileSyncFn) {
+  const existing = packageJSONCache.get(path);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const source = readFileSyncFn(path);
+  if (source === void 0) {
+    const packageConfig2 = {
+      pjsonPath: path,
+      exists: false,
+      main: void 0,
+      name: void 0,
+      type: "none",
+      exports: void 0,
+      imports: void 0
+    };
+    packageJSONCache.set(path, packageConfig2);
+    return packageConfig2;
+  }
+  let packageJSON;
+  try {
+    packageJSON = JSONParse(source);
+  } catch (error) {
+    throw new ERR_INVALID_PACKAGE_CONFIG(
+      path,
+      (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier),
+      error.message
+    );
+  }
+  let { imports, main, name, type } = filterOwnProperties(packageJSON, [
+    "imports",
+    "main",
+    "name",
+    "type"
+  ]);
+  const exports = ObjectPrototypeHasOwnProperty(packageJSON, "exports") ? packageJSON.exports : void 0;
+  if (typeof imports !== "object" || imports === null) {
+    imports = void 0;
+  }
+  if (typeof main !== "string") {
+    main = void 0;
+  }
+  if (typeof name !== "string") {
+    name = void 0;
+  }
+  if (type !== "module" && type !== "commonjs") {
+    type = "none";
+  }
+  const packageConfig = {
+    pjsonPath: path,
+    exists: true,
+    main,
+    name,
+    type,
+    exports,
+    imports
+  };
+  packageJSONCache.set(path, packageConfig);
+  return packageConfig;
+}
+function getPackageScopeConfig(resolved, readFileSyncFn) {
+  let packageJSONUrl = new URL("./package.json", resolved);
+  while (true) {
+    const packageJSONPath2 = packageJSONUrl.pathname;
+    if (StringPrototypeEndsWith(packageJSONPath2, "node_modules/package.json")) {
+      break;
+    }
+    const packageConfig2 = getPackageConfig(
+      fileURLToPath(packageJSONUrl),
+      resolved,
+      void 0,
+      readFileSyncFn
+    );
+    if (packageConfig2.exists) {
+      return packageConfig2;
+    }
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new URL("../package.json", packageJSONUrl);
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
+      break;
+    }
+  }
+  const packageJSONPath = fileURLToPath(packageJSONUrl);
+  const packageConfig = {
+    pjsonPath: packageJSONPath,
+    exists: false,
+    main: void 0,
+    name: void 0,
+    type: "none",
+    exports: void 0,
+    imports: void 0
+  };
+  packageJSONCache.set(packageJSONPath, packageConfig);
+  return packageConfig;
+}
+
+function throwImportNotDefined(specifier, packageJSONUrl, base) {
+  throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJSONUrl && fileURLToPath(new URL(".", packageJSONUrl)),
+    fileURLToPath(base)
+  );
+}
+function throwInvalidSubpath(subpath, packageJSONUrl, internal, base) {
+  const reason = `request is not a valid subpath for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath(packageJSONUrl)}`;
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    subpath,
+    reason,
+    base && fileURLToPath(base)
+  );
+}
+function throwInvalidPackageTarget(subpath, target, packageJSONUrl, internal, base) {
+  if (typeof target === "object" && target !== null) {
+    target = JSONStringify(target, null, "");
+  } else {
+    target = `${target}`;
+  }
+  throw new ERR_INVALID_PACKAGE_TARGET(
+    fileURLToPath(new URL(".", packageJSONUrl)),
+    subpath,
+    target,
+    internal,
+    base && fileURLToPath(base)
+  );
+}
+const invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
+const patternRegEx = /\*/g;
+function resolvePackageTargetString(target, subpath, match, packageJSONUrl, base, pattern, internal, conditions) {
+  if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
+    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
+  if (!StringPrototypeStartsWith(target, "./")) {
+    if (internal && !StringPrototypeStartsWith(target, "../") && !StringPrototypeStartsWith(target, "/")) {
+      let isURL = false;
+      try {
+        new URL(target);
+        isURL = true;
+      } catch {
+      }
+      if (!isURL) {
+        const exportTarget = pattern ? RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) : target + subpath;
+        return exportTarget;
+      }
+    }
+    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
+  }
+  if (RegExpPrototypeExec(
+    invalidSegmentRegEx,
+    StringPrototypeSlice(target, 2)
+  ) !== null)
+    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
+  const resolved = new URL(target, packageJSONUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL(".", packageJSONUrl).pathname;
+  if (!StringPrototypeStartsWith(resolvedPath, packagePath))
+    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
+  if (subpath === "")
+    return resolved;
+  if (RegExpPrototypeExec(invalidSegmentRegEx, subpath) !== null) {
+    const request = pattern ? StringPrototypeReplace(match, "*", () => subpath) : match + subpath;
+    throwInvalidSubpath(request, packageJSONUrl, internal, base);
+  }
+  if (pattern) {
+    return new URL(
+      RegExpPrototypeSymbolReplace(patternRegEx, resolved.href, () => subpath)
+    );
+  }
+  return new URL(subpath, resolved);
+}
+function isArrayIndex(key) {
+  const keyNum = +key;
+  if (`${keyNum}` !== key)
+    return false;
+  return keyNum >= 0 && keyNum < 4294967295;
+}
+function resolvePackageTarget(packageJSONUrl, target, subpath, packageSubpath, base, pattern, internal, conditions) {
+  if (typeof target === "string") {
+    return resolvePackageTargetString(
+      target,
+      subpath,
+      packageSubpath,
+      packageJSONUrl,
+      base,
+      pattern,
+      internal);
+  } else if (ArrayIsArray(target)) {
+    if (target.length === 0) {
+      return null;
+    }
+    let lastException;
+    for (let i = 0; i < target.length; i++) {
+      const targetItem = target[i];
+      let resolveResult;
+      try {
+        resolveResult = resolvePackageTarget(
+          packageJSONUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          conditions
+        );
+      } catch (e) {
+        lastException = e;
+        if (e.code === "ERR_INVALID_PACKAGE_TARGET") {
+          continue;
+        }
+        throw e;
+      }
+      if (resolveResult === void 0) {
+        continue;
+      }
+      if (resolveResult === null) {
+        lastException = null;
+        continue;
+      }
+      return resolveResult;
+    }
+    if (lastException === void 0 || lastException === null)
+      return lastException;
+    throw lastException;
+  } else if (typeof target === "object" && target !== null) {
+    const keys = ObjectGetOwnPropertyNames(target);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG(
+          fileURLToPath(packageJSONUrl),
+          base,
+          '"exports" cannot contain numeric property keys.'
+        );
+      }
+    }
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key === "default" || conditions.has(key)) {
+        const conditionalTarget = target[key];
+        const resolveResult = resolvePackageTarget(
+          packageJSONUrl,
+          conditionalTarget,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          conditions
+        );
+        if (resolveResult === void 0)
+          continue;
+        return resolveResult;
+      }
+    }
+    return void 0;
+  } else if (target === null) {
+    return null;
+  }
+  throwInvalidPackageTarget(
+    packageSubpath,
+    target,
+    packageJSONUrl,
+    internal,
+    base
+  );
+}
+function patternKeyCompare(a, b) {
+  const aPatternIndex = StringPrototypeIndexOf(a, "*");
+  const bPatternIndex = StringPrototypeIndexOf(b, "*");
+  const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
+  const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
+  if (baseLenA > baseLenB)
+    return -1;
+  if (baseLenB > baseLenA)
+    return 1;
+  if (aPatternIndex === -1)
+    return 1;
+  if (bPatternIndex === -1)
+    return -1;
+  if (a.length > b.length)
+    return -1;
+  if (b.length > a.length)
+    return 1;
+  return 0;
+}
+function packageImportsResolve({ name, base, conditions, readFileSyncFn }) {
+  if (name === "#" || StringPrototypeStartsWith(name, "#/") || StringPrototypeEndsWith(name, "/")) {
+    const reason = "is not a valid internal imports specifier name";
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base));
+  }
+  let packageJSONUrl;
+  const packageConfig = getPackageScopeConfig(base, readFileSyncFn);
+  if (packageConfig.exists) {
+    packageJSONUrl = pathToFileURL(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (ObjectPrototypeHasOwnProperty(imports, name) && !StringPrototypeIncludes(name, "*")) {
+        const resolveResult = resolvePackageTarget(
+          packageJSONUrl,
+          imports[name],
+          "",
+          name,
+          base,
+          false,
+          true,
+          conditions
+        );
+        if (resolveResult != null) {
+          return resolveResult;
+        }
+      } else {
+        let bestMatch = "";
+        let bestMatchSubpath;
+        const keys = ObjectGetOwnPropertyNames(imports);
+        for (let i = 0; i < keys.length; i++) {
+          const key = keys[i];
+          const patternIndex = StringPrototypeIndexOf(key, "*");
+          if (patternIndex !== -1 && StringPrototypeStartsWith(
+            name,
+            StringPrototypeSlice(key, 0, patternIndex)
+          )) {
+            const patternTrailer = StringPrototypeSlice(key, patternIndex + 1);
+            if (name.length >= key.length && StringPrototypeEndsWith(name, patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && StringPrototypeLastIndexOf(key, "*") === patternIndex) {
+              bestMatch = key;
+              bestMatchSubpath = StringPrototypeSlice(
+                name,
+                patternIndex,
+                name.length - patternTrailer.length
+              );
+            }
+          }
+        }
+        if (bestMatch) {
+          const target = imports[bestMatch];
+          const resolveResult = resolvePackageTarget(
+            packageJSONUrl,
+            target,
+            bestMatchSubpath,
+            bestMatch,
+            base,
+            true,
+            true,
+            conditions
+          );
+          if (resolveResult != null) {
+            return resolveResult;
+          }
+        }
+      }
+    }
+  }
+  throwImportNotDefined(name, packageJSONUrl, base);
+}
+
+const pathRegExp = /^(?![a-zA-Z]:[\\/]|\\\\|\.{0,2}(?:\/|$))((?:node:)?(?:@[^/]+\/)?[^/]+)\/*(.*|)$/;
+const isRelativeRegexp = /^\.{0,2}\//;
+function tryReadFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, `utf8`);
+  } catch (err) {
+    if (err.code === `ENOENT`)
+      return void 0;
+    throw err;
+  }
+}
+async function resolvePrivateRequest(specifier, issuer, context, nextResolve) {
+  const resolved = packageImportsResolve({
+    name: specifier,
+    base: pathToFileURL(issuer),
+    conditions: new Set(context.conditions),
+    readFileSyncFn: tryReadFile
+  });
+  if (resolved instanceof URL) {
+    return { url: resolved.href, shortCircuit: true };
+  } else {
+    if (resolved.startsWith(`#`))
+      throw new Error(`Mapping from one private import to another isn't allowed`);
+    return resolve$1(resolved, context, nextResolve);
+  }
+}
+async function resolve$1(originalSpecifier, context, nextResolve) {
+  const { findPnpApi } = moduleExports;
+  if (!findPnpApi || isBuiltin(originalSpecifier))
+    return nextResolve(originalSpecifier, context, nextResolve);
+  let specifier = originalSpecifier;
+  const url = tryParseURL(specifier, isRelativeRegexp.test(specifier) ? context.parentURL : void 0);
+  if (url) {
+    if (url.protocol !== `file:`)
+      return nextResolve(originalSpecifier, context, nextResolve);
+    specifier = fileURLToPath(url);
+  }
+  const { parentURL, conditions = [] } = context;
+  const issuer = parentURL && tryParseURL(parentURL)?.protocol === `file:` ? fileURLToPath(parentURL) : process.cwd();
+  const pnpapi = findPnpApi(issuer) ?? (url ? findPnpApi(specifier) : null);
+  if (!pnpapi)
+    return nextResolve(originalSpecifier, context, nextResolve);
+  if (specifier.startsWith(`#`))
+    return resolvePrivateRequest(specifier, issuer, context, nextResolve);
+  const dependencyNameMatch = specifier.match(pathRegExp);
+  let allowLegacyResolve = false;
+  if (dependencyNameMatch) {
+    const [, dependencyName, subPath] = dependencyNameMatch;
+    if (subPath === `` && dependencyName !== `pnpapi`) {
+      const resolved = pnpapi.resolveToUnqualified(`${dependencyName}/package.json`, issuer);
+      if (resolved) {
+        const content = await tryReadFile$1(resolved);
+        if (content) {
+          const pkg = JSON.parse(content);
+          allowLegacyResolve = pkg.exports == null;
+        }
+      }
+    }
+  }
+  let result;
+  try {
+    result = pnpapi.resolveRequest(specifier, issuer, {
+      conditions: new Set(conditions),
+      extensions: allowLegacyResolve ? void 0 : []
+    });
+  } catch (err) {
+    if (err instanceof Error && `code` in err && err.code === `MODULE_NOT_FOUND`)
+      err.code = `ERR_MODULE_NOT_FOUND`;
+    throw err;
+  }
+  if (!result)
+    throw new Error(`Resolving '${specifier}' from '${issuer}' failed`);
+  const resultURL = pathToFileURL(result);
+  if (url) {
+    resultURL.search = url.search;
+    resultURL.hash = url.hash;
+  }
+  if (!parentURL)
+    setEntrypointPath(fileURLToPath(resultURL));
+  return {
+    url: resultURL.href,
+    shortCircuit: true
+  };
+}
+
+if (!HAS_LAZY_LOADED_TRANSLATORS) {
+  const binding = process.binding(`fs`);
+  const originalReadFile = binding.readFileUtf8 || binding.readFileSync;
+  if (originalReadFile) {
+    binding[originalReadFile.name] = function(...args) {
+      try {
+        return fs.readFileSync(args[0], {
+          encoding: `utf8`,
+          flag: args[1]
+        });
+      } catch {
+      }
+      return originalReadFile.apply(this, args);
+    };
+  } else {
+    const binding2 = process.binding(`fs`);
+    const originalfstat = binding2.fstat;
+    const ZIP_MASK = 4278190080;
+    const ZIP_MAGIC = 704643072;
+    binding2.fstat = function(...args) {
+      const [fd, useBigint, req] = args;
+      if ((fd & ZIP_MASK) === ZIP_MAGIC && useBigint === false && req === void 0) {
+        try {
+          const stats = fs.fstatSync(fd);
+          return new Float64Array([
+            stats.dev,
+            stats.mode,
+            stats.nlink,
+            stats.uid,
+            stats.gid,
+            stats.rdev,
+            stats.blksize,
+            stats.ino,
+            stats.size,
+            stats.blocks
+          ]);
+        } catch {
+        }
+      }
+      return originalfstat.apply(this, args);
+    };
+  }
+}
+
+const resolve = resolve$1;
+const load = load$1;
+
+export { load, resolve };

next/components/dunbar/DunbarApp.js

+import { useEffect, useMemo, useRef, useState } from 'react';
+import styles from '@/styles/dunbar.module.css';
+import { useDunbarStore } from '@/components/dunbar/useDunbarStore';
+import dynamic from 'next/dynamic';
+import { makeExportPayload } from '@/lib/dunbar';
+
+// Lazy-load heavy tabs if needed (Network uses d3)
+const NetworkTab = dynamic(() => import('@/components/dunbar/NetworkTab'), { ssr: false });
+const OrbitsTab = dynamic(() => import('@/components/dunbar/OrbitsTab'), { ssr: false });
+const EventsTab = dynamic(() => import('@/components/dunbar/EventsTab'), { ssr: false });
+
+// Lightweight components
+import FriendsList from '@/components/dunbar/FriendsList';
+import FriendDetail from '@/components/dunbar/FriendDetail';
+import StatsTab from '@/components/dunbar/StatsTab';
+
+const PASSWORD = 'freehugs4all';
+
+function Tabs({ tab, setTab }) {
+  const items = [
+    { id: 'friends', label: 'Friends' },
+    { id: 'events', label: 'Events' },
+    { id: 'orbits', label: 'Orbits' },
+    { id: 'network', label: 'Network' },
+    { id: 'stats', label: 'Stats' },
+  ];
+  return (
+    <div className={styles.tabs}>
+      {items.map((it) => (
+        <button
+          key={it.id}
+          className={`${styles.tabBtn} ${tab === it.id ? styles.tabActive : ''}`}
+          onClick={() => setTab(it.id)}
+        >
+          {it.label}
+        </button>
+      ))}
+    </div>
+  );
+}
+
+export default function DunbarApp() {
+  const { state, friends, selectedFriendId, actions, derived } = useDunbarStore();
+  const [tab, setTab] = useState('friends');
+  const [authed, setAuthed] = useState(false);
+  const [lockError, setLockError] = useState('');
+  const friendsListScrollRef = useRef(0);
+  const fileInputRef = useRef(null);
+
+  // Password gate: prompt once per session
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+    const stored = window.sessionStorage.getItem('dunbarAuthed');
+    if (stored === '1') {
+      setAuthed(true);
+      return;
+    }
+    // show lock UI; user presses "Unlock" to prompt
+  }, []);
+
+  const handleUnlock = () => {
+    if (typeof window === 'undefined') return;
+    const ans = window.prompt('Enter password for Dunbar');
+    if (ans === PASSWORD) {
+      window.sessionStorage.setItem('dunbarAuthed', '1');
+      setAuthed(true);
+      setLockError('');
+    } else {
+      setLockError('Wrong password. Try again.');
+    }
+  };
+
+  const selectedFriend = useMemo(() => friends.find((f) => f.id === selectedFriendId) || null, [friends, selectedFriendId]);
+
+  // Export / Import
+  const onExport = () => {
+    try {
+      const payload = makeExportPayload(state);
+      const blob = new Blob([JSON.stringify(payload, null, 2)], { type: 'application/json' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = 'dunbar-export.json';
+      a.click();
+      URL.revokeObjectURL(url);
+    } catch (e) {
+      // eslint-disable-next-line no-alert
+      alert('Export failed');
+    }
+  };
+  const onImportClick = () => fileInputRef.current?.click();
+  const onImportFile = async (e) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+    try {
+      const text = await file.text();
+      const json = JSON.parse(text);
+      actions.loadFromPayload(json);
+    } catch {
+      // eslint-disable-next-line no-alert
+      alert('Invalid import file');
+    } finally {
+      e.target.value = '';
+    }
+  };
+
+  // Navigation from viz → friend detail
+  const openFriendDetail = (friendId) => {
+    actions.selectFriend(friendId);
+    setTab('friends');
+  };
+
+  if (!authed) {
+    return (
+      <div className={styles.lockWrap}>
+        <h2 className={styles.title}>Dunbar</h2>
+        <p>Privacy-first relationship navigator. Local-only storage.</p>
+        <button className={styles.btn} onClick={handleUnlock}>Unlock</button>
+        {lockError ? <div style={{ color: '#b91c1c', marginTop: 8 }}>{lockError}</div> : null}
+      </div>
+    );
+  }
+
+  return (
+    <div className={styles.container}>
+      <div className={styles.header}>
+        <div className={styles.row}>
+          <h1 className={styles.title}>Dunbar</h1>
+          <span className={styles.badge}>{friends.length} friends</span>
+        </div>
+        <div className={styles.toolbar}>
+          <button className={styles.btnSecondary} onClick={onExport}>Export</button>
+          <button className={styles.btnSecondary} onClick={onImportClick}>Import</button>
+          <input
+            ref={fileInputRef}
+            type="file"
+            accept="application/json"
+            onChange={onImportFile}
+            style={{ display: 'none' }}
+          />
+          <button className={styles.btnSecondary} onClick={actions.resetData}>Reset Data</button>
+        </div>
+      </div>
+
+      <Tabs tab={tab} setTab={setTab} />
+
+      {tab === 'friends' && (
+        <div className={styles.twoCol}>
+          <div>
+            <FriendsList
+              friends={friends}
+              selectedFriendId={selectedFriendId}
+              onSelect={(id) => actions.selectFriend(id)}
+              onAddFriend={(name) => actions.addFriend(name)}
+              onRemoveFriend={(id) => actions.removeFriend(id)}
+              onRename={(id, name) => actions.renameFriend(id, name)}
+              // preserve list scroll when opening/closing detail
+              onSaveScroll={(y) => (friendsListScrollRef.current = y)}
+              initialScroll={friendsListScrollRef.current}
+              getConnectionCount={(id) => derived ? null : null}
+            />
+          </div>
+          <div>
+            <FriendDetail
+              friend={selectedFriend}
+              friends={friends}
+              onToggleRel={(a, b) => actions.toggleRelationship(a, b)}
+              onAddEvent={(payload) => actions.addEvent(payload)}
+              onRename={(id, name) => actions.renameFriend(id, name)}
+              // scroll preservation inside relationship list handled internally
+            />
+          </div>
+        </div>
+      )}
+
+      {tab === 'events' && (
+        <EventsTab
+          friends={friends}
+          addEvent={(payload) => actions.addEvent(payload)}
+          eventIndex={derived.eventIndex}
+        />
+      )}
+
+      {tab === 'orbits' && (
+        <OrbitsTab
+          friends={friends}
+          buckets={derived.orbitBuckets}
+          openFriendDetail={openFriendDetail}
+        />
+      )}
+
+      {tab === 'network' && (
+        <NetworkTab
+          friends={friends}
+          toggleRel={(a, b) => actions.toggleRelationship(a, b)}
+          openFriendDetail={openFriendDetail}
+        />
+      )}
+
+      {tab === 'stats' && (
+        <StatsTab stats={derived.stats} />
+      )}
+    </div>
+  );
+}

next/components/dunbar/EventsTab.js

+import { useMemo, useState } from 'react';
+import styles from '@/styles/dunbar.module.css';
+import {
+  todayISO,
+  yesterdayISO,
+  weekAgoISO,
+  startOfMonthISO,
+  groupEventsByDay,
+  isoDate,
+} from '@/lib/dunbar';
+
+export default function EventsTab({ friends, addEvent, eventIndex }) {
+  // Creation form state
+  const [date, setDate] = useState(todayISO());
+  const [notes, setNotes] = useState('');
+  const [location, setLocation] = useState('');
+  const [filter, setFilter] = useState('');
+  const [selected, setSelected] = useState(() => new Set());
+
+  const friendMap = useMemo(() => {
+    const m = new Map();
+    for (const f of friends) m.set(f.id, f);
+    return m;
+  }, [friends]);
+
+  const filteredFriends = useMemo(() => {
+    const q = filter.trim().toLowerCase();
+    if (!q) return friends;
+    return friends.filter((f) => f.name.toLowerCase().includes(q));
+  }, [friends, filter]);
+
+  const toggleFriend = (id) => {
+    const s = new Set(selected);
+    if (s.has(id)) s.delete(id);
+    else s.add(id);
+    setSelected(s);
+  };
+
+  const selectedCount = selected.size;
+  const canCreate = selectedCount > 0 && notes.trim().length > 0;
+
+  const createEvent = () => {
+    if (!canCreate) return;
+    const dateISO = new Date(date).toISOString();
+    addEvent({
+      date: dateISO,
+      notes: notes.trim(),
+      location: location.trim() || undefined,
+      participants: Array.from(selected),
+    });
+    // reset minimal fields, keep filter/selection to ease batch creation
+    setNotes('');
+  };
+
+  // Timeline groups from merged eventIndex
+  const groups = useMemo(() => groupEventsByDay(eventIndex), [eventIndex]);
+
+  return (
+    <div className={styles.twoCol} style={{ gap: 16 }}>
+      {/* New Event Builder */}
+      <div className={styles.card}>
+        <div className={styles.cardHeader}>
+          <span>New Event</span>
+        </div>
+        <div className={styles.row} style={{ gap: 8, marginBottom: 8, flexWrap: 'wrap' }}>
+          <button className={styles.btnSecondary} onClick={() => setDate(todayISO())}>Today</button>
+          <button className={styles.btnSecondary} onClick={() => setDate(yesterdayISO())}>Yesterday</button>
+          <button className={styles.btnSecondary} onClick={() => setDate(weekAgoISO())}>Week Ago</button>
+          <button className={styles.btnSecondary} onClick={() => setDate(startOfMonthISO())}>Start of Month</button>
+        </div>
+        <div className={styles.row} style={{ marginBottom: 8, flexWrap: 'wrap' }}>
+          <input
+            type="date"
+            className={styles.input}
+            value={date}
+            onChange={(e) => setDate(e.target.value)}
+          />
+          <input
+            className={styles.input}
+            placeholder="Location (optional)"
+            value={location}
+            onChange={(e) => setLocation(e.target.value)}
+            style={{ minWidth: 160 }}
+          />
+        </div>
+        <div className={styles.row} style={{ marginBottom: 8 }}>
+          <textarea
+            className={styles.textarea}
+            placeholder="Notes (required)"
+            value={notes}
+            onChange={(e) => setNotes(e.target.value)}
+            style={{ width: '100%' }}
+          />
+        </div>
+
+        <div className={styles.card} style={{ marginTop: 8 }}>
+          <div className={styles.cardHeader}>
+            <span>Friends ({selectedCount} selected)</span>
+            <input
+              className={styles.input}
+              placeholder="Search friends…"
+              value={filter}
+              onChange={(e) => setFilter(e.target.value)}
+            />
+          </div>
+          <div className={styles.scroll}>
+            {filteredFriends.map((f) => {
+              const checked = selected.has(f.id);
+              return (
+                <label key={f.id} className={styles.switchRow} style={{ cursor: 'pointer' }}>
+                  <input
+                    type="checkbox"
+                    checked={checked}
+                    onChange={() => toggleFriend(f.id)}
+                  />
+                  <span style={{ fontWeight: 600, marginLeft: 8 }}>{f.name}</span>
+                </label>
+              );
+            })}
+            {filteredFriends.length === 0 && (
+              <div style={{ padding: 8, color: '#666' }}>No matches.</div>
+            )}
+          </div>
+        </div>
+
+        <div className={styles.row} style={{ marginTop: 12 }}>
+          <button className={styles.btn} onClick={createEvent} disabled={!canCreate}>
+            Create Event
+          </button>
+        </div>
+      </div>
+
+      {/* Timeline */}
+      <div className={styles.card}>
+        <div className={styles.cardHeader}>Timeline</div>
+        <div className={styles.timeline}>
+          {groups.map((g) => (
+            <div key={g.dateKey} className={styles.timelineGroup}>
+              <div className={styles.timelineDate}>{g.label}</div>
+              {g.items.map((e) => {
+                const names = (e.participants || [])
+                  .map((id) => friendMap.get(id)?.name)
+                  .filter(Boolean);
+                return (
+                  <div key={e.id + e.date} className={styles.timelineEvent}>
+                    <div><strong>{names.join(', ') || 'Unknown'}</strong></div>
+                    <div style={{ whiteSpace: 'pre-wrap' }}>{e.notes}</div>
+                    {e.location ? (
+                      <div style={{ color: '#555', marginTop: 4 }}>📍 {e.location}</div>
+                    ) : null}
+                    <div style={{ color: '#888', marginTop: 4, fontSize: 12 }}>
+                      {isoDate(e.date)}
+                    </div>
+                  </div>
+                );
+              })}
+            </div>
+          ))}
+          {groups.length === 0 && (
+            <div style={{ color: '#666' }}>No events yet — create one on the left.</div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

next/components/dunbar/FriendDetail.js

+import { useEffect, useMemo, useRef, useState } from 'react';
+import styles from '@/styles/dunbar.module.css';
+import { isoDate, sortEventsDesc } from '@/lib/dunbar';
+
+
+export default function FriendDetail({
+  friend,
+  friends,
+  onToggleRel,   // (aId, bId) => void
+  onAddEvent,    // ({ date, notes, participants[], location? }) => void
+}) {
+  const [date, setDate] = useState(() => new Date().toISOString().slice(0, 10));
+  const [notes, setNotes] = useState('');
+  const [location, setLocation] = useState('');
+  const relScrollRef = useRef(null);
+
+  // Scroll preservation for toggles: store + restore scrollTop across updates
+  const beforeToggle = useRef(0);
+  const restorePending = useRef(false);
+  useEffect(() => {
+    if (restorePending.current && relScrollRef.current) {
+      const st = beforeToggle.current;
+      // Restore next tick
+      const id = setTimeout(() => {
+        try {
+          relScrollRef.current.scrollTop = st;
+        } catch {}
+        restorePending.current = false;
+      }, 0);
+      return () => clearTimeout(id);
+    }
+  });
+
+  const others = useMemo(() => {
+    if (!friend) return [];
+    return friends.filter((f) => f.id !== friend.id);
+  }, [friend, friends]);
+
+  const friendRelSet = useMemo(() => {
+    return friend ? friend.relationships || new Set() : new Set();
+  }, [friend]);
+
+  const eventsDesc = useMemo(() => {
+    if (!friend) return [];
+    return sortEventsDesc(friend.events);
+  }, [friend]);
+
+  const onToggle = (targetId) => {
+    if (!friend) return;
+    if (relScrollRef.current) beforeToggle.current = relScrollRef.current.scrollTop;
+    restorePending.current = true;
+    onToggleRel?.(friend.id, targetId);
+  };
+
+  const submitEvent = () => {
+    if (!friend) return;
+    const dateISO = new Date(date).toISOString();
+    const n = notes.trim();
+    if (!dateISO || !n) return;
+    onAddEvent?.({
+      date: dateISO,
+      notes: n,
+      location: location.trim() || undefined,
+      participants: [friend.id],
+    });
+    // reset notes only; keep date for faster entry
+    setNotes('');
+  };
+
+  if (!friend) {
+    return (
+      <div className={styles.card}>
+        <div className={styles.cardHeader}>Friend details</div>
+        <div style={{ color: '#666' }}>Select a friend from the list to view and edit details.</div>
+      </div>
+    );
+  }
+
+  const evCount = Array.isArray(friend.events) ? friend.events.length : 0;
+  const connCount = friend.relationships ? friend.relationships.size : 0;
+
+  return (
+    <div className={styles.card}>
+      <div className={styles.cardHeader}>
+        <span>{friend.name}</span>
+        <span className={styles.badge}>{evCount} events · {connCount} connections</span>
+      </div>
+
+      <div className={styles.twoCol} style={{ gap: 12 }}>
+        {/* Relationships */}
+        <div className={styles.card}>
+          <div className={styles.cardHeader}>
+            <span>Relationships ({others.length})</span>
+          </div>
+          <div ref={relScrollRef} className={styles.scroll}>
+            {others.map((o) => {
+              const onRel = friendRelSet.has(o.id);
+              return (
+                <div key={o.id} className={styles.switchRow}>
+                  <div style={{ minWidth: 160, fontWeight: 600 }}>{o.name}</div>
+                  <div
+                    className={`${styles.switch} ${onRel ? styles.switchOn : ''}`}
+                    onClick={() => onToggle(o.id)}
+                    title={onRel ? 'Connected — click to remove' : 'Not connected — click to connect'}
+                    style={{ cursor: 'pointer' }}
+                  >
+                    <div className={`${styles.knob} ${onRel ? styles.knobOn : ''}`} />
+                  </div>
+                </div>
+              );
+            })}
+            {others.length === 0 && (
+              <div style={{ padding: 8, color: '#666' }}>No other friends to connect yet.</div>
+            )}
+          </div>
+        </div>
+
+        {/* Events */}
+        <div className={styles.card}>
+          <div className={styles.cardHeader}>
+            <span>Events</span>
+          </div>
+
+          {/* Add Event */}
+          <div className={styles.row} style={{ marginBottom: 8, flexWrap: 'wrap' }}>
+            <input
+              type="date"
+              className={styles.input}
+              value={date}
+              onChange={(e) => setDate(e.target.value)}
+            />
+            <input
+              className={styles.input}
+              placeholder="Location (optional)"
+              value={location}
+              onChange={(e) => setLocation(e.target.value)}
+              style={{ minWidth: 160 }}
+            />
+          </div>
+          <div className={styles.row} style={{ marginBottom: 8 }}>
+            <textarea
+              className={styles.textarea}
+              placeholder="Notes (required)"
+              value={notes}
+              onChange={(e) => setNotes(e.target.value)}
+              style={{ width: '100%' }}
+            />
+          </div>
+          <div className={styles.row} style={{ marginBottom: 12 }}>
+            <button className={styles.btn} onClick={submitEvent} disabled={!notes.trim()}>
+              Add Event
+            </button>
+          </div>
+
+          {/* Timeline */}
+          <div className={styles.timeline}>
+            {eventsDesc.map((e) => (
+              <div key={e.id + e.date} className={styles.timelineEvent}>
+                <div className={styles.timelineDate}>
+                  {isoDate(e.date)}
+                </div>
+                <div style={{ whiteSpace: 'pre-wrap' }}>{e.notes}</div>
+                {e.location ? (
+                  <div style={{ color: '#555', marginTop: 4 }}>📍 {e.location}</div>
+                ) : null}
+              </div>
+            ))}
+            {eventsDesc.length === 0 && (
+              <div style={{ color: '#666' }}>No events yet — add your first memory above.</div>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

next/components/dunbar/FriendsList.js

+import { useEffect, useMemo, useRef, useState } from 'react';
+import styles from '@/styles/dunbar.module.css';
+
+export default function FriendsList({
+  friends,
+  selectedFriendId,
+  onSelect,
+  onAddFriend,
+  onRemoveFriend,
+  onRename,        // (id, name) => void
+  onSaveScroll,    // (scrollTop:number) => void
+  initialScroll = 0,
+}) {
+  const [name, setName] = useState('');
+  const [filter, setFilter] = useState('');
+  const [editingId, setEditingId] = useState(null);
+  const [editName, setEditName] = useState('');
+  const scrollRef = useRef(null);
+
+  // Restore scroll position when mounting / when list changes (preserve UX)
+  useEffect(() => {
+    if (!scrollRef.current) return;
+    // Next tick to allow DOM layout to settle
+    const id = setTimeout(() => {
+      try {
+        scrollRef.current.scrollTop = initialScroll || 0;
+      } catch {}
+    }, 0);
+    return () => clearTimeout(id);
+  }, [friends, initialScroll]);
+
+  const filtered = useMemo(() => {
+    const q = filter.trim().toLowerCase();
+    if (!q) return friends;
+    return friends.filter((f) => f.name.toLowerCase().includes(q));
+  }, [friends, filter]);
+
+  const handleAdd = () => {
+    const n = name.trim();
+    if (!n) return;
+    onAddFriend?.(n);
+    setName('');
+  };
+
+  const onClickItem = (id) => {
+    // Save current scroll before navigating to detail
+    if (scrollRef.current) onSaveScroll?.(scrollRef.current.scrollTop);
+    onSelect?.(id);
+  };
+
+  // Inline rename helpers
+  const startEdit = (id, currentName) => {
+    setEditingId(id);
+    setEditName(currentName || '');
+  };
+  const commitEdit = () => {
+    if (!editingId) return;
+    const n = editName.trim();
+    if (n) onRename?.(editingId, n);
+    setEditingId(null);
+    setEditName('');
+  };
+  const cancelEdit = () => {
+    setEditingId(null);
+    setEditName('');
+  };
+
+  return (
+    <div>
+      <div className={styles.card} style={{ marginBottom: 12 }}>
+        <div className={styles.cardHeader}>
+          <span>Friends ({friends.length})</span>
+          <div className={styles.row}>
+            <input
+              className={styles.input}
+              placeholder="Filter..."
+              value={filter}
+              onChange={(e) => setFilter(e.target.value)}
+            />
+          </div>
+        </div>
+        <div className={styles.row}>
+          <input
+            className={styles.input}
+            placeholder="Add a friend by name"
+            value={name}
+            onChange={(e) => setName(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter') handleAdd();
+            }}
+          />
+          <button className={styles.btn} onClick={handleAdd} disabled={!name.trim()}>
+            Add
+          </button>
+        </div>
+      </div>
+
+      <div className={styles.list}>
+        <div ref={scrollRef} className={styles.listScroll}>
+          {filtered.map((f) => {
+            const evCount = Array.isArray(f.events) ? f.events.length : 0;
+            const connCount = f.relationships ? f.relationships.size : 0;
+            const isSel = f.id === selectedFriendId;
+            const isEditing = editingId === f.id;
+            return (
+              <div
+                key={f.id}
+                className={styles.listItem}
+                onClick={() => onClickItem(f.id)}
+                style={isSel ? { background: '#f5fbf7' } : undefined}
+              >
+                {isEditing ? (
+                  <input
+                    className={styles.input}
+                    value={editName}
+                    autoFocus
+                    onClick={(e) => e.stopPropagation()}
+                    onChange={(e) => setEditName(e.target.value)}
+                    onBlur={commitEdit}
+                    onKeyDown={(e) => {
+                      if (e.key === 'Enter') {
+                        e.preventDefault();
+                        commitEdit();
+                      } else if (e.key === 'Escape') {
+                        e.preventDefault();
+                        cancelEdit();
+                      }
+                    }}
+                    style={{ maxWidth: 220 }}
+                  />
+                ) : (
+                  <div
+                    className={styles.itemTitle}
+                    title="Click to rename"
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      startEdit(f.id, f.name);
+                    }}
+                    style={{ cursor: 'text' }}
+                  >
+                    {f.name}
+                  </div>
+                )}
+                <div className={styles.itemMeta}>
+                  &nbsp;·&nbsp;{evCount} events · {connCount} connections
+                </div>
+                <div className={styles.itemRight} aria-hidden>›</div>
+                <button
+                  className={styles.btnSecondary}
+                  style={{ marginLeft: 8 }}
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    const ok = window.confirm(`Remove ${f.name}? This doesn’t delete events from others.`);
+                    if (!ok) return;
+                    onRemoveFriend?.(f.id);
+                  }}
+                >
+                  Remove
+                </button>
+              </div>
+            );
+          })}
+          {filtered.length === 0 && (
+            <div style={{ padding: 12, color: '#666' }}>
+              {friends.length === 0
+                ? 'No friends yet — add your first contact above.'
+                : 'No matches for your filter.'}
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

next/components/dunbar/NetworkTab.js

+import { useEffect, useMemo, useRef, useState } from 'react';
+import styles from '@/styles/dunbar.module.css';
+import {
+  degreeMap,
+  edgesFromFriends,
+  drawLabel,
+  clamp,
+} from '@/lib/dunbar';
+
+// We only rely on d3-force for physics. Zoom/pan/drag implemented manually to avoid extra deps.
+export default function NetworkTab({ friends, toggleRel, openFriendDetail }) {
+  const containerRef = useRef(null);
+  const canvasRef = useRef(null);
+  const simRef = useRef(null);
+  const rafRef = useRef(0);
+
+  // Canvas sizing
+  const [size, setSize] = useState({ w: 800, h: 500 });
+  useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const ro = new ResizeObserver(() => {
+      const r = el.getBoundingClientRect();
+      setSize({ w: Math.max(300, r.width), h: Math.max(300, r.height) });
+    });
+    ro.observe(el);
+    const r = el.getBoundingClientRect();
+    setSize({ w: Math.max(300, r.width), h: Math.max(300, r.height) });
+    return () => ro.disconnect();
+  }, []);
+
+  // Transform for pan/zoom
+  const [transform, setTransform] = useState({ k: 1, x: 0, y: 0 });
+  const worldFromScreen = (sx, sy) => ({
+    x: (sx - transform.x) / transform.k,
+    y: (sy - transform.y) / transform.k,
+  });
+
+  // Graph data derived from friends
+  const nodes = useMemo(() => friends.map(f => ({
+    id: String(f.id),
+    name: f.name,
+  })), [friends]);
+
+  const degreeM = useMemo(() => degreeMap(friends), [friends]);
+  const links = useMemo(() => edgesFromFriends(friends).map(([a,b]) => ({ source: String(a), target: String(b) })), [friends]);
+
+  // Node state (positions) persisted across renders
+  const nodeStateRef = useRef(new Map()); // id -> {x,y,vx,vy}
+  const getNodeState = (id) => {
+    let s = nodeStateRef.current.get(id);
+    if (!s) {
+      // seed around center
+      s = {
+        x: (Math.random() - 0.5) * 200,
+        y: (Math.random() - 0.5) * 200,
+        vx: 0, vy: 0,
+      };
+      nodeStateRef.current.set(id, s);
+    }
+    return s;
+  };
+
+  // Simulation setup/refresh
+  const [physicsOn, setPhysicsOn] = useState(true);
+  useEffect(() => {
+    let stopped = false;
+    let sim;
+    async function setup() {
+      const d3 = await import('d3-force');
+      const d3force = d3; // module namespace
+      // Build d3 nodes referencing our state map
+      const d3Nodes = nodes.map(n => {
+        const s = getNodeState(n.id);
+        return { id: n.id, x: s.x, y: s.y, vx: s.vx, vy: s.vy };
+      });
+      const d3Links = links.map(l => ({ source: l.source, target: l.target }));
+
+      sim = d3force.forceSimulation(d3Nodes)
+        .force('charge', d3force.forceManyBody().strength(-80))
+        .force('link', d3force.forceLink(d3Links).id(d => d.id).distance(80).strength(0.2))
+        .force('center', d3force.forceCenter(0, 0))
+        .force('collide', d3force.forceCollide(18));
+
+      if (!physicsOn) {
+        sim.alphaTarget(0).stop();
+      } else {
+        sim.alpha(0.8).alphaTarget(0.03).restart();
+      }
+
+      sim.on('tick', () => {
+        if (stopped) return;
+        // Persist positions back to our state map
+        for (const n of d3Nodes) {
+          const s = getNodeState(n.id);
+          s.x = n.x;
+          s.y = n.y;
+          s.vx = n.vx || 0;
+          s.vy = n.vy || 0;
+        }
+        requestDraw();
+      });
+
+      simRef.current = sim;
+    }
+    setup();
+    return () => {
+      stopped = true;
+      if (sim) sim.stop();
+      simRef.current = null;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [nodes, links, physicsOn]); // rebuild when graph or physics toggles
+
+  // Drawing
+  const requestDraw = () => {
+    if (rafRef.current) return;
+    rafRef.current = requestAnimationFrame(() => {
+      rafRef.current = 0;
+      draw();
+    });
+  };
+
+  const nodeRadius = (id) => {
+    const deg = degreeM.get(id) || 0;
+    return clamp(6 + deg * 0.8, 6, 18);
+    // color by degree buckets as specified
+  };
+  const nodeColor = (id) => {
+    const deg = degreeM.get(id) || 0;
+    if (deg >= 10) return '#2c5530'; // dark green
+    if (deg >= 5) return '#5a9960';  // medium green
+    if (deg >= 1) return '#a0c0a0';  // light green
+    return '#c0c0c0';                // gray for 0
+  };
+
+  const draw = () => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    const ctx = canvas.getContext('2d');
+    const { w, h } = size;
+
+    // DPR scaling
+    const dpr = window.devicePixelRatio || 1;
+    canvas.width = w * dpr;
+    canvas.height = h * dpr;
+    canvas.style.width = `${w}px`;
+    canvas.style.height = `${h}px`;
+
+    ctx.save();
+    ctx.scale(dpr, dpr);
+
+    // clear
+    ctx.clearRect(0, 0, w, h);
+
+    // apply transform (pan/zoom)
+    ctx.translate(transform.x, transform.y);
+    ctx.scale(transform.k, transform.k);
+
+    // Draw links
+    ctx.lineWidth = 1 / transform.k;
+    ctx.strokeStyle = '#e0e0e0';
+    for (const l of links) {
+      const a = getNodeState(String(l.source));
+      const b = getNodeState(String(l.target));
+      if (!a || !b) continue;
+      ctx.beginPath();
+      ctx.moveTo(a.x, a.y);
+      ctx.lineTo(b.x, b.y);
+      ctx.stroke();
+    }
+
+    // Draw nodes
+    for (const n of nodes) {
+      const s = getNodeState(n.id);
+      const r = nodeRadius(n.id);
+      ctx.beginPath();
+      ctx.fillStyle = nodeColor(n.id);
+      ctx.arc(s.x, s.y, r, 0, Math.PI * 2);
+      ctx.fill();
+    }
+
+    // Labels (keep readable irrespective of zoom)
+    ctx.scale(1 / transform.k, 1 / transform.k); // neutralize zoom for label size
+    for (const n of nodes) {
+      const s = getNodeState(n.id);
+      drawLabel(ctx, n.name, transform.k * s.x + transform.x, transform.k * s.y + transform.y - 14, '#333');
+    }
+
+    ctx.restore();
+  };
+
+  useEffect(() => { requestDraw(); }, [size, transform, nodes, links, degreeM]); // redraw on deps
+
+  // Interaction
+  const stateRef = useRef({
+    draggingNodeId: null,
+    dragOffset: { x: 0, y: 0 },
+    panning: false,
+    panStart: { x: 0, y: 0 },
+    transformStart: { x: 0, y: 0 },
+    linkDraftFrom: null, // id when in edit mode and dragging a link
+    lastMouse: { x: 0, y: 0 },
+  });
+
+  const [editMode, setEditMode] = useState(false);
+
+  const pickNodeAt = (sx, sy) => {
+    const { x, y } = worldFromScreen(sx, sy);
+    // simple hit test
+    for (let i = nodes.length - 1; i >= 0; i--) {
+      const n = nodes[i];
+      const s = getNodeState(n.id);
+      const r = nodeRadius(n.id);
+      const dx = x - s.x;
+      const dy = y - s.y;
+      if (dx * dx + dy * dy <= r * r) return n.id;
+    }
+    return null;
+  };
+
+  const onMouseDown = (e) => {
+    const rect = canvasRef.current.getBoundingClientRect();
+    const sx = e.clientX - rect.left;
+    const sy = e.clientY - rect.top;
+    const id = pickNodeAt(sx, sy);
+    stateRef.current.lastMouse = { x: sx, y: sy };
+
+    if (id) {
+      if (editMode) {
+        // start link draft
+        stateRef.current.linkDraftFrom = id;
+      } else {
+        // start dragging node
+        stateRef.current.draggingNodeId = id;
+        const { x, y } = worldFromScreen(sx, sy);
+        const s = getNodeState(id);
+        stateRef.current.dragOffset = { x: s.x - x, y: s.y - y };
+        // Nudge simulation
+        if (simRef.current && physicsOn) {
+          simRef.current.alphaTarget(0.1).restart();
+        }
+      }
+    } else {
+      // start panning
+      stateRef.current.panning = true;
+      stateRef.current.panStart = { x: sx, y: sy };
+      stateRef.current.transformStart = { x: transform.x, y: transform.y };
+    }
+  };
+
+  const onMouseMove = (e) => {
+    const rect = canvasRef.current.getBoundingClientRect();
+    const sx = e.clientX - rect.left;
+    const sy = e.clientY - rect.top;
+    stateRef.current.lastMouse = { x: sx, y: sy };
+
+    if (stateRef.current.draggingNodeId) {
+      const id = stateRef.current.draggingNodeId;
+      const { x, y } = worldFromScreen(sx, sy);
+      const s = getNodeState(id);
+      s.x = x + stateRef.current.dragOffset.x;
+      s.y = y + stateRef.current.dragOffset.y;
+      // reflect back to simulation node if exists
+      if (simRef.current) {
+        const d3node = simRef.current.nodes().find(n => n.id === id);
+        if (d3node) {
+          d3node.fx = s.x;
+          d3node.fy = s.y;
+        }
+      }
+      requestDraw();
+      return;
+    }
+
+    if (stateRef.current.panning) {
+      const dx = sx - stateRef.current.panStart.x;
+      const dy = sy - stateRef.current.panStart.y;
+      setTransform(t => ({ ...t, x: stateRef.current.transformStart.x + dx, y: stateRef.current.transformStart.y + dy }));
+      return;
+    }
+
+    // if link draft, just redraw (we draw draft in overlay)
+    if (stateRef.current.linkDraftFrom) {
+      requestDraw();
+    }
+  };
+
+  const onMouseUp = (e) => {
+    const rect = canvasRef.current.getBoundingClientRect();
+    const sx = e.clientX - rect.left;
+    const sy = e.clientY - rect.top;
+    const overId = pickNodeAt(sx, sy);
+
+    if (stateRef.current.draggingNodeId) {
+      const id = stateRef.current.draggingNodeId;
+      stateRef.current.draggingNodeId = null;
+      // release fixed position so sim can settle (unless physics off)
+      if (simRef.current) {
+        const d3node = simRef.current.nodes().find(n => n.id === id);
+        if (d3node) {
+          d3node.fx = null;
+          d3node.fy = null;
+        }
+      }
+    } else if (stateRef.current.panning) {
+      stateRef.current.panning = false;
+    } else if (stateRef.current.linkDraftFrom) {
+      const from = stateRef.current.linkDraftFrom;
+      stateRef.current.linkDraftFrom = null;
+      if (overId && overId !== from) {
+        // Toggle bidirectional link
+        toggleRel?.(from, overId);
+      }
+    } else if (!editMode && overId) {
+      // View mode click node -> open friend detail
+      openFriendDetail?.(overId);
+    }
+    requestDraw();
+  };
+
+  const onWheel = (e) => {
+    e.preventDefault();
+    const rect = canvasRef.current.getBoundingClientRect();
+    const sx = e.clientX - rect.left;
+    const sy = e.clientY - rect.top;
+
+    const factor = Math.exp(-e.deltaY * 0.0015);
+    const newK = clamp(transform.k * factor, 0.2, 4);
+
+    // zoom to cursor
+    const wx0 = (sx - transform.x) / transform.k;
+    const wy0 = (sy - transform.y) / transform.k;
+    const x = sx - wx0 * newK;
+    const y = sy - wy0 * newK;
+    setTransform({ k: newK, x, y });
+  };
+
+  // Overlay draw (draft link)
+  useEffect(() => {
+    // draw overlay line for link draft
+    if (!stateRef.current.linkDraftFrom) return;
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    const ctx = canvas.getContext('2d');
+    const { w, h } = size;
+    const dpr = window.devicePixelRatio || 1;
+
+    ctx.save();
+    ctx.scale(dpr, dpr);
+    // simply call main draw then overlay the draft line
+    draw();
+
+    const fromId = stateRef.current.linkDraftFrom;
+    const s = getNodeState(fromId);
+    const { x: sx, y: sy } = stateRef.current.lastMouse;
+    const p = worldFromScreen(sx, sy);
+
+    ctx.translate(transform.x, transform.y);
+    ctx.scale(transform.k, transform.k);
+    ctx.beginPath();
+    ctx.moveTo(s.x, s.y);
+    ctx.lineTo(p.x, p.y);
+    ctx.strokeStyle = '#5a9960';
+    ctx.lineWidth = 2 / transform.k;
+    ctx.setLineDash([6 / transform.k, 4 / transform.k]);
+    ctx.stroke();
+    ctx.restore();
+  });
+
+  return (
+    <div>
+      <div className={styles.graphToolbar}>
+        <button
+          className={styles.btnSecondary}
+          onClick={() => setPhysicsOn(v => !v)}
+          title="Toggle physics simulation"
+        >
+          Physics: {physicsOn ? 'On' : 'Off'}
+        </button>
+        <button
+          className={styles.btnSecondary}
+          onClick={() => setEditMode(v => !v)}
+          title="Toggle edit mode to create/remove connections"
+        >
+          Mode: {editMode ? 'Edit' : 'View'}
+        </button>
+        <span className={styles.badge}>{nodes.length} nodes · {links.length} edges</span>
+      </div>
+      {editMode && (
+        <div className={styles.banner}>Edit mode: Drag from one node to another to toggle a connection.</div>
+      )}
+      <div
+        ref={containerRef}
+        className={styles.canvasWrap}
+      >
+        <canvas
+          ref={canvasRef}
+          width={size.w}
+          height={size.h}
+          onMouseDown={onMouseDown}
+          onMouseMove={onMouseMove}
+          onMouseUp={onMouseUp}
+          onWheel={onWheel}
+        />
+      </div>
+    </div>
+  );
+}

next/components/dunbar/OrbitsTab.js

+import { useEffect, useMemo, useRef, useState } from 'react';
+import styles from '@/styles/dunbar.module.css';
+import Tooltip from '@/components/dunbar/Tooltip';
+import {
+  distributeOnCircle,
+  colorByActivity,
+  firstWords,
+  isoDate,
+} from '@/lib/dunbar';
+
+function useSize(ref) {
+  const [size, setSize] = useState({ w: 800, h: 500 });
+  useEffect(() => {
+    if (!ref.current) return;
+    const el = ref.current;
+    const ro = new ResizeObserver(() => {
+      const r = el.getBoundingClientRect();
+      setSize({ w: Math.max(300, r.width), h: Math.max(300, r.height) });
+    });
+    ro.observe(el);
+    const r = el.getBoundingClientRect();
+    setSize({ w: Math.max(300, r.width), h: Math.max(300, r.height) });
+    return () => ro.disconnect();
+  }, [ref]);
+  return size;
+}
+
+function countRecentEvents(friend, days = 90) {
+  const now = Date.now();
+  const win = days * 24 * 60 * 60 * 1000;
+  let c = 0;
+  for (const e of friend.events || []) {
+    const t = new Date(e.date).getTime();
+    if (!isNaN(t) && now - t <= win) c += 1;
+  }
+  return c;
+}
+
+export default function OrbitsTab({ friends, buckets, openFriendDetail }) {
+  const wrapRef = useRef(null);
+  const { w, h } = useSize(wrapRef);
+
+  const cx = w / 2;
+  const cy = h / 2;
+  const rOuter = Math.min(w, h) * 0.45;
+  const rMiddle = Math.min(w, h) * 0.32;
+  const rInner = Math.min(w, h) * 0.18;
+
+  const friendMap = useMemo(() => {
+    const m = new Map();
+    for (const f of friends) m.set(f.id, f);
+    return m;
+  }, [friends]);
+
+  // Positions for each orbit
+  const posInner = useMemo(() => distributeOnCircle(buckets.inner || [], rInner, cx, cy, -Math.PI / 2), [buckets.inner, cx, cy, rInner]);
+  const posMiddle = useMemo(() => distributeOnCircle(buckets.middle || [], rMiddle, cx, cy, -Math.PI / 2), [buckets.middle, cx, cy, rMiddle]);
+  const posOuter = useMemo(() => distributeOnCircle(buckets.outer || [], rOuter, cx, cy, -Math.PI / 2), [buckets.outer, cx, cy, rOuter]);
+
+  const [tooltip, setTooltip] = useState({ x: 0, y: 0, show: false, html: null });
+
+  const handleEnter = (e, id) => {
+    const f = friendMap.get(id);
+    if (!f) return;
+    const totalEvents = (f.events || []).length;
+    const connectionCount = f.relationships ? f.relationships.size : 0;
+    const recent = [...(f.events || [])]
+      .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+      .slice(0, 3)
+      .map((ev) => `${isoDate(ev.date)}: ${firstWords(ev.notes, 3)}…`);
+
+    setTooltip({
+      x: e.clientX,
+      y: e.clientY,
+      show: true,
+      html: (
+        <div>
+          <div style={{ fontWeight: 800, marginBottom: 4 }}>{f.name}</div>
+          <div>Total events: {totalEvents}</div>
+          <div>Connections: {connectionCount}</div>
+          {recent.length ? (
+            <div style={{ marginTop: 6 }}>
+              {recent.map((line, i) => (
+                <div key={i} style={{ color: '#555' }}>{line}</div>
+              ))}
+            </div>
+          ) : null}
+        </div>
+      ),
+    });
+  };
+
+  const handleMove = (e) => {
+    setTooltip((t) => ({ ...t, x: e.clientX, y: e.clientY }));
+  };
+  const handleLeave = () => setTooltip((t) => ({ ...t, show: false }));
+
+  const renderNodes = (ids, posMap) => {
+    return ids.map((id) => {
+      const p = posMap.get(id);
+      const f = friendMap.get(id);
+      if (!p || !f) return null;
+      const c90 = countRecentEvents(f, 90);
+      const fill = colorByActivity(c90);
+      return (
+        <g key={id} transform={`translate(${p.x},${p.y})`} style={{ cursor: 'pointer' }}>
+          <circle
+            r={10}
+            fill={fill}
+            onMouseEnter={(e) => handleEnter(e, id)}
+            onMouseMove={handleMove}
+            onMouseLeave={handleLeave}
+            onClick={() => openFriendDetail?.(id)}
+          />
+          <text className={styles.nodeLabel} textAnchor="middle" y={-14}>
+            {f.name}
+          </text>
+        </g>
+      );
+    });
+  };
+
+  return (
+    <div ref={wrapRef} className={styles.orbitsWrap}>
+      <svg width="100%" height="100%" viewBox={`0 0 ${w} ${h}`} role="img" aria-label="Orbits visualization">
+        {/* Orbits */}
+        <circle cx={cx} cy={cy} r={rOuter} fill="none" stroke="#e8efe9" />
+        <circle cx={cx} cy={cy} r={rMiddle} fill="none" stroke="#d7e7db" />
+        <circle cx={cx} cy={cy} r={rInner} fill="none" stroke="#c9e0cf" />
+        {/* Labels */}
+        <text x={cx} y={cy - rInner - 8} className={styles.orbitLabel} textAnchor="middle">Close</text>
+        <text x={cx} y={cy - rMiddle - 8} className={styles.orbitLabel} textAnchor="middle">Regular</text>
+        <text x={cx} y={cy - rOuter - 8} className={styles.orbitLabel} textAnchor="middle">Distant</text>
+
+        {/* Nodes */}
+        {renderNodes(buckets.inner || [], posInner)}
+        {renderNodes(buckets.middle || [], posMiddle)}
+        {renderNodes(buckets.outer || [], posOuter)}
+      </svg>
+
+      <Tooltip x={tooltip.x} y={tooltip.y} visible={tooltip.show}>
+        {tooltip.html}
+      </Tooltip>
+    </div>
+  );
+}

next/components/dunbar/StatsTab.js

+import React from 'react';
+import styles from '@/styles/dunbar.module.css';
+
+export default function StatsTab({ stats }) {
+  if (!stats) return null;
+  const items = [
+    { label: 'Connections', value: stats.connections },
+    { label: 'Active Friends (90d)', value: stats.activeFriends },
+    { label: 'Total Events', value: stats.totalEvents },
+    { label: 'Avg Events / Friend', value: stats.avgEventsPerFriend },
+  ];
+  return (
+    <div className={styles.card}>
+      <div className={styles.cardHeader}>Statistics</div>
+      <div className={styles.statsGrid}>
+        {items.map((it) => (
+          <div key={it.label} className={styles.statCard}>
+            <div className={styles.statLabel}>{it.label}</div>
+            <div className={styles.statValue}>{it.value}</div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}

next/components/dunbar/Tooltip.js

+import React from 'react';
+import styles from '@/styles/dunbar.module.css';
+
+export default function Tooltip({ x, y, visible, children }) {
+  if (!visible) return null;
+  // Keep tooltip within viewport bounds with a small offset
+  const offset = 12;
+  const style = {
+    left: Math.max(8, x + offset),
+    top: Math.max(8, y + offset),
+  };
+  return (
+    <div className={styles.tooltip} style={style} role="tooltip">
+      {children}
+    </div>
+  );
+}

next/components/dunbar/useDunbarStore.js

+import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
+import { normalizeImportedPayload } from '@/lib/dunbar';
+
+const LS_KEY = 'dunbar-state-v1';
+
+// Helpers
+const uuid = () => (typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : `id_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+const nowISO = () => new Date().toISOString();
+
+function serializeState(state) {
+  const friends = state.friends.map((f) => ({
+    ...f,
+    relationships: Array.from(f.relationships || []),
+  }));
+  return JSON.stringify({ friends, selectedFriendId: state.selectedFriendId });
+}
+
+function deserializeState(json) {
+  try {
+    const data = JSON.parse(json);
+    if (!data || !Array.isArray(data.friends)) return null;
+    const friends = data.friends.map((f) => ({
+      ...f,
+      relationships: new Set(f.relationships || []),
+      events: Array.isArray(f.events) ? f.events : [],
+    }));
+    return { friends, selectedFriendId: data.selectedFriendId || null };
+  } catch {
+    return null;
+  }
+}
+
+function computeLastInteraction(friend) {
+  if (!friend.events || friend.events.length === 0) return null;
+  const max = friend.events.reduce((acc, e) => {
+    const t = new Date(e.date).getTime();
+    return Math.max(acc, isNaN(t) ? 0 : t);
+  }, 0);
+  return max ? new Date(max).toISOString() : null;
+}
+
+const initialState = {
+  friends: [],
+  selectedFriendId: null,
+};
+
+function reducer(state, action) {
+  switch (action.type) {
+    case 'LOAD': {
+      return action.payload || state;
+    }
+    case 'ADD_FRIEND': {
+      const name = String(action.payload?.name || '').trim();
+      if (!name) return state;
+      const newFriend = {
+        id: uuid(),
+        name,
+        relationships: new Set(),
+        events: [],
+        lastInteraction: null,
+      };
+      return { ...state, friends: [...state.friends, newFriend] };
+    }
+    case 'REMOVE_FRIEND': {
+      const id = action.payload?.id;
+      if (!id) return state;
+      const friends = state.friends
+        .filter((f) => f.id !== id)
+        .map((f) => {
+          if (f.relationships?.has(id)) {
+            const rel = new Set(f.relationships);
+            rel.delete(id);
+            return { ...f, relationships: rel };
+          }
+          return f;
+        });
+      return {
+        ...state,
+        friends,
+        selectedFriendId: state.selectedFriendId === id ? null : state.selectedFriendId,
+      };
+    }
+    case 'RENAME_FRIEND': {
+      const { id, name } = action.payload || {};
+      if (!id) return state;
+      const n = String(name || '').trim();
+      if (!n) return state;
+      const friends = state.friends.map((f) => (f.id === id ? { ...f, name: n } : f));
+      return { ...state, friends };
+    }
+    case 'SELECT_FRIEND': {
+      const id = action.payload?.id ?? null;
+      return { ...state, selectedFriendId: id };
+    }
+    case 'TOGGLE_REL': {
+      const a = action.payload?.aId;
+      const b = action.payload?.bId;
+      if (!a || !b || a === b) return state;
+      const friends = state.friends.map((f) => {
+        if (f.id === a) {
+          const rel = new Set(f.relationships || []);
+          rel.has(b) ? rel.delete(b) : rel.add(b);
+          return { ...f, relationships: rel };
+        }
+        if (f.id === b) {
+          const rel = new Set(f.relationships || []);
+          rel.has(a) ? rel.delete(a) : rel.add(a);
+          return { ...f, relationships: rel };
+        }
+        return f;
+      });
+      return { ...state, friends };
+    }
+    case 'ADD_EVENT': {
+      const { date, notes, participants = [], location } = action.payload || {};
+      const dateISO = date ? new Date(date).toISOString() : null;
+      if (!dateISO || !notes || !participants.length) return state;
+
+      const eventId = uuid();
+      // Create one logical event id applied to each participant for deduplication across views
+      const friends = state.friends.map((f) => {
+        if (participants.includes(f.id)) {
+          const ev = {
+            id: eventId,
+            date: dateISO,
+            notes: String(notes),
+            location: location ? String(location) : undefined,
+            participants: [...participants],
+          };
+          const events = Array.isArray(f.events) ? [...f.events, ev] : [ev];
+          const lastInteraction = computeLastInteraction({ ...f, events });
+          return { ...f, events, lastInteraction };
+        }
+        return f;
+      });
+      return { ...state, friends };
+    }
+    case 'RESET': {
+      return { ...initialState };
+    }
+    default:
+      return state;
+  }
+}
+
+/**
+ * Dunbar data store with localStorage persistence and derived helpers.
+ */
+export function useDunbarStore() {
+  const didInitRef = useRef(false);
+  const [state, dispatch] = useReducer(reducer, initialState);
+
+  // Load persisted state (client-only)
+  useEffect(() => {
+    if (didInitRef.current) return;
+    didInitRef.current = true;
+    if (typeof window === 'undefined') return;
+    const raw = window.localStorage.getItem(LS_KEY);
+    const loaded = raw ? deserializeState(raw) : null;
+    if (loaded) {
+      // Patch lastInteraction on load
+      const patched = {
+        ...loaded,
+        friends: loaded.friends.map((f) => ({
+          ...f,
+          lastInteraction: computeLastInteraction(f),
+        })),
+      };
+      dispatch({ type: 'LOAD', payload: patched });
+    }
+  }, []);
+
+  // Auto-save to localStorage on change
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+    try {
+      const serialized = serializeState(state);
+      window.localStorage.setItem(LS_KEY, serialized);
+    } catch {
+      // ignore
+    }
+  }, [state]);
+
+  // Actions
+  const addFriend = useCallback((name) => dispatch({ type: 'ADD_FRIEND', payload: { name } }), []);
+  const removeFriend = useCallback((id) => dispatch({ type: 'REMOVE_FRIEND', payload: { id } }), []);
+  const selectFriend = useCallback((id) => dispatch({ type: 'SELECT_FRIEND', payload: { id } }), []);
+  const toggleRelationship = useCallback((aId, bId) => dispatch({ type: 'TOGGLE_REL', payload: { aId, bId } }), []);
+  const addEvent = useCallback((payload) => dispatch({ type: 'ADD_EVENT', payload }), []);
+  const resetData = useCallback(() => {
+    if (typeof window !== 'undefined') {
+      const ok = window.confirm('This will clear all Dunbar data. Continue?');
+      if (!ok) return;
+      window.localStorage.removeItem(LS_KEY);
+    }
+    dispatch({ type: 'RESET' });
+  }, []);
+
+  const renameFriend = useCallback((id, name) => {
+    dispatch({ type: 'RENAME_FRIEND', payload: { id, name } });
+  }, []);
+
+  const loadFromPayload = useCallback((payload) => {
+    try {
+      const normalized = normalizeImportedPayload(payload);
+      const patched = {
+        ...normalized,
+        friends: normalized.friends.map((f) => ({
+          ...f,
+          lastInteraction: computeLastInteraction(f),
+        })),
+      };
+      dispatch({ type: 'LOAD', payload: patched });
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error('Dunbar import failed', e);
+    }
+  }, []);
+
+  // Derived helpers
+  const friendMap = useMemo(() => {
+    const m = new Map();
+    for (const f of state.friends) m.set(f.id, f);
+    return m;
+  }, [state.friends]);
+
+  const getFriendById = useCallback((id) => friendMap.get(id) || null, [friendMap]);
+
+  const getConnectionCount = useCallback(
+    (id) => {
+      const f = friendMap.get(id);
+      return f?.relationships ? f.relationships.size : 0;
+    },
+    [friendMap]
+  );
+
+  const getEventCount = useCallback(
+    (id) => {
+      const f = friendMap.get(id);
+      return Array.isArray(f?.events) ? f.events.length : 0;
+    },
+    [friendMap]
+  );
+
+  // Stats
+  const stats = useMemo(() => {
+    const friends = state.friends;
+    let edges = 0;
+    let totalEvents = 0;
+    const now = Date.now();
+    const ninety = 90 * 24 * 60 * 60 * 1000;
+    let activeFriends = 0;
+    for (const f of friends) {
+      edges += (f.relationships?.size || 0);
+      const evCount = Array.isArray(f.events) ? f.events.length : 0;
+      totalEvents += evCount;
+      const hasRecent = (f.events || []).some((e) => now - new Date(e.date).getTime() <= ninety);
+      if (hasRecent) activeFriends += 1;
+    }
+    const uniqueConnections = Math.floor(edges / 2);
+    const avgEvents = friends.length ? +(totalEvents / friends.length).toFixed(2) : 0;
+    return {
+      connections: uniqueConnections,
+      activeFriends,
+      totalEvents,
+      avgEventsPerFriend: avgEvents,
+    };
+  }, [state.friends]);
+
+  // Orbits (last 90 days)
+  const orbitBuckets = useMemo(() => {
+    const now = Date.now();
+    const ninety = 90 * 24 * 60 * 60 * 1000;
+    const counts = state.friends.map((f) => {
+      const c = (f.events || []).reduce((acc, e) => {
+        const t = new Date(e.date).getTime();
+        return acc + (now - t <= ninety ? 1 : 0);
+      }, 0);
+      return { id: f.id, name: f.name, count90: c };
+    });
+    const inner = [];
+    const middle = [];
+    const outer = [];
+    for (const it of counts) {
+      if (it.count90 >= 5) inner.push(it.id);
+      else if (it.count90 >= 2) middle.push(it.id);
+      else outer.push(it.id);
+    }
+    return { inner, middle, outer };
+  }, [state.friends]);
+
+  // Event index by id across all friends (for timeline dedup)
+  const eventIndex = useMemo(() => {
+    const idx = new Map();
+    for (const f of state.friends) {
+      for (const e of f.events || []) {
+        if (!idx.has(e.id)) {
+          idx.set(e.id, { ...e, participants: new Set(e.participants || []) });
+        } else {
+          const curr = idx.get(e.id);
+          for (const pid of e.participants || []) curr.participants.add(pid);
+        }
+      }
+    }
+    // Normalize participants back to array
+    const merged = Array.from(idx.values()).map((e) => ({ ...e, participants: Array.from(e.participants) }));
+    return merged;
+  }, [state.friends]);
+
+  return {
+    state,
+    friends: state.friends,
+    selectedFriendId: state.selectedFriendId,
+    actions: {
+      addFriend,
+      removeFriend,
+      renameFriend,
+      selectFriend,
+      toggleRelationship,
+      addEvent,
+      resetData,
+      loadFromPayload,
+    },
+    helpers: {
+      getFriendById,
+      getConnectionCount,
+      getEventCount,
+    },
+    derived: {
+      stats,
+      orbitBuckets,
+      eventIndex,
+    },
+  };
+}

next/components/layout.js

@@ -7,7 +7,7 @@ import Router from 'next/router'
 
 const name = "PLN";
 export const siteTitle = "PLN's Works";
-export const siteURL = "https://me.plnech.fr";
+export const siteURL = "https://me.nech.pl";
 export const twitterHandle = "@PaulLouisNech";
 export const description = "PLN's Selected Works";
 
@@ -78,7 +78,7 @@ export default function Layout({ children, home }) {
         </div>
       )}
       <footer>
-        PLN 2024 | ☇
+        PLN 2025 | ☇
         <a
           href="https://vercel.com?utm_source=create-next-app&utm_medium=default-template&utm_campaign=create-next-app"
           target="_blank"

next/lib/dunbar.js

+// Dunbar shared utilities — keep UI components lean and consistent.
+// Import via: import { ... } from '@/lib/dunbar';
+
+// Locale & time zone defaults (French, Paris)
+export const LOCALE = 'fr-FR';
+export const TIMEZONE = 'Europe/Paris';
+
+// ------------------------------
+// Internal helpers for timezone-safe local dates
+// ------------------------------
+function partsInTZ(dateLike, timeZone = TIMEZONE) {
+  const d = dateLike instanceof Date ? dateLike : new Date(dateLike);
+  if (isNaN(d.getTime())) return null;
+  const fmt = new Intl.DateTimeFormat(LOCALE, {
+    timeZone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  });
+  // fr-FR gives dd/mm/yyyy — use formatToParts to recompose safely
+  const parts = fmt.formatToParts(d);
+  const map = Object.fromEntries(parts.map(p => [p.type, p.value]));
+  // Ensure 2-digit month/day
+  const yyyy = map.year;
+  const mm = map.month;
+  const dd = map.day;
+  return { yyyy, mm, dd };
+}
+
+function ymdInTZ(dateLike, timeZone = TIMEZONE) {
+  const p = partsInTZ(dateLike, timeZone);
+  if (!p) return '';
+  return `${p.yyyy}-${p.mm}-${p.dd}`;
+}
+
+// ------------------------------
+// Dates & text formatting
+// ------------------------------
+export function isoDate(dateLike, timeZone = TIMEZONE) {
+  return ymdInTZ(dateLike, timeZone);
+}
+
+export function fullDateLabel(dateLike, locale = LOCALE, timeZone = TIMEZONE) {
+  try {
+    const d = dateLike instanceof Date ? dateLike : new Date(dateLike);
+    if (isNaN(d.getTime())) return '';
+    return d.toLocaleDateString(locale, {
+      timeZone,
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+    });
+  } catch {
+    return '';
+  }
+}
+
+export function firstWords(text, n = 3) {
+  if (!text) return '';
+  const words = String(text).trim().split(/\s+/);
+  return words.slice(0, n).join(' ');
+}
+
+// Quick-date helpers (ISO YYYY-MM-DD) — Paris local calendar
+export function todayISO() {
+  return isoDate(new Date(), TIMEZONE);
+}
+export function yesterdayISO() {
+  const d = new Date();
+  d.setDate(d.getDate() - 1);
+  return isoDate(d, TIMEZONE);
+}
+export function weekAgoISO() {
+  const d = new Date();
+  d.setDate(d.getDate() - 7);
+  return isoDate(d, TIMEZONE);
+}
+export function startOfMonthISO() {
+  const d = new Date();
+  d.setDate(1);
+  return isoDate(d, TIMEZONE);
+}
+
+// ------------------------------
+// Events helpers
+// ------------------------------
+
+// Sort newest first by date
+export function sortEventsDesc(events) {
+  return [...(events || [])].sort(
+    (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+  );
+}
+
+// Group events (array) by local Paris day (YYYY-MM-DD). Returns [{ dateKey, label, items }]
+export function groupEventsByDay(events, locale = LOCALE, timeZone = TIMEZONE) {
+  const groups = new Map();
+  for (const e of events || []) {
+    const key = isoDate(e.date, timeZone);
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(e);
+  }
+  const out = [];
+  for (const [dateKey, items] of groups.entries()) {
+    out.push({
+      dateKey,
+      label: fullDateLabel(dateKey, locale, timeZone),
+      items: sortEventsDesc(items),
+    });
+  }
+  // Sort groups by day (newest first)
+  out.sort((a, b) => new Date(b.dateKey).getTime() - new Date(a.dateKey).getTime());
+  return out;
+}
+
+// ------------------------------
+// Orbits helpers (positions & colors)
+// ------------------------------
+export function distributeOnCircle(ids = [], radius = 100, cx = 0, cy = 0, startAngle = 0) {
+  const n = ids.length || 1;
+  const step = (2 * Math.PI) / n;
+  const pos = new Map();
+  ids.forEach((id, i) => {
+    const angle = startAngle + i * step;
+    const x = cx + radius * Math.cos(angle);
+    const y = cy + radius * Math.sin(angle);
+    pos.set(id, { x, y, angle });
+  });
+  return pos;
+}
+
+// Activity color coding based on last-90-days interaction counts
+export function colorByActivity(count90) {
+  if (count90 >= 5) return '#2c5530'; // dark green
+  if (count90 >= 2) return '#5a9960'; // medium green
+  return '#a0c0a0'; // light green
+}
+
+// ------------------------------
+// Network helpers
+// ------------------------------
+export function degreeMap(friends = []) {
+  const m = new Map();
+  for (const f of friends) {
+    m.set(f.id, (f.relationships && f.relationships.size) || 0);
+  }
+  return m;
+}
+
+export function edgesFromFriends(friends = []) {
+  // Build unique undirected edges [a,b] with a < b to avoid duplicates
+  const seen = new Set();
+  const edges = [];
+  for (const f of friends) {
+    for (const to of f.relationships || []) {
+      const a = String(f.id);
+      const b = String(to);
+      if (a === b) continue;
+      const key = a < b ? `${a}::${b}` : `${b}::${a}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push([a, b]);
+    }
+  }
+  return edges;
+}
+
+// ------------------------------
+// Math & drawing helpers
+// ------------------------------
+export const clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+export const lerp = (a, b, t) => a + (b - a) * t;
+
+// Canvas label drawing with white stroke for contrast
+export function drawLabel(ctx, text, x, y, color = '#333', fontPx = 12) {
+  ctx.save();
+  ctx.font = `${fontPx}px system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, sans-serif`;
+  ctx.lineWidth = Math.max(2, fontPx / 4);
+  ctx.strokeStyle = '#fff';
+  ctx.strokeText(text, x, y);
+  ctx.fillStyle = color;
+  ctx.fillText(text, x, y);
+  ctx.restore();
+}
+
+// ------------------------------
+// Versioned import/export helpers
+// ------------------------------
+export const DATA_VERSION = '1.0.0';
+export const DATA_SCHEMA = 'dunbar-v1';
+
+// Prepare JSON-safe snapshot (relationships as arrays)
+export function makeExportPayload(state) {
+  const friends = (state.friends || []).map(f => ({
+    id: f.id,
+    name: f.name,
+    relationships: Array.from(f.relationships || []),
+    events: Array.isArray(f.events) ? f.events.map(ev => ({
+      id: ev.id,
+      date: ev.date,
+      notes: ev.notes,
+      location: ev.location,
+      participants: Array.isArray(ev.participants) ? [...ev.participants] : [],
+    })) : [],
+  }));
+  return {
+    schema: DATA_SCHEMA,
+    version: DATA_VERSION,
+    savedAt: new Date().toISOString(),
+    selectedFriendId: state.selectedFriendId || null,
+    friends,
+  };
+}
+
+export function normalizeImportedPayload(payload) {
+  if (!payload) throw new Error('Empty payload');
+  // Accept same schema or a minimal legacy shape { friends, selectedFriendId }
+  const friendsRaw = Array.isArray(payload.friends) ? payload.friends : [];
+  const friends = friendsRaw.map(f => ({
+    id: f.id,
+    name: f.name || '',
+    relationships: new Set(Array.isArray(f.relationships) ? f.relationships : []),
+    events: Array.isArray(f.events) ? f.events.map(ev => ({
+      id: ev.id,
+      date: ev.date,
+      notes: ev.notes || '',
+      location: ev.location,
+      participants: Array.isArray(ev.participants) ? ev.participants : [],
+    })) : [],
+    lastInteraction: null, // computed by store
+  }));
+  return {
+    friends,
+    selectedFriendId: payload.selectedFriendId || null,
+  };
+}

next/package.json

@@ -19,6 +19,8 @@
     "@tailwindcss/aspect-ratio": "^0.4.2",
     "bootstrap": "^5.3.3",
     "classnames": "^2.5.1",
+    "d3-force": "^3.0.0",
+    "d3-zoom": "^3.0.0",
     "date-fns": "^3.3.1",
     "gray-matter": "^4.0.3",
     "hydra-synth": "^1.3.29",
@@ -41,5 +43,6 @@
     "@types/react": "^18.2.61",
     "typescript": "^5.3.3",
     "vercel": "^39"
-  }
+  },
+  "packageManager": "yarn@4.1.0+sha512.5b7bc055cad63273dda27df1570a5d2eb4a9f03b35b394d3d55393c2a5560a17f5cef30944b11d6a48bcbcfc1c3a26d618aae77044774c529ba36cb771ad5b0f"
 }

next/pages/dunbar/DESIGN.md

+# Dunbar MVP v0.1 design
+
+A # DUNBAR Social Network Navigation Assistant Implementation Guide.
+
+## Executive Summary
+DUNBAR is a privacy-first relationship management system based on Dunbar's number theory (5/15/50/150) expansion of human ability to nurture relationships -- a kind of social aug mod to multiply yourself. This guide provides stack-agnostic implementation requirements for recreating the validated prototype features.
+
+## Core Data Model
+
+### Friend Entity
+```
+Friend {
+  id: unique_identifier
+  name: string
+  relationships: Set<friend_id>  // Bidirectional connections
+  events: Array<Event>
+  lastInteraction: date (computed from events)
+}
+```
+
+### Event Entity
+```
+Event {
+  id: unique_identifier
+  date: date
+  notes: string (required)
+  location: string (optional)
+  participants: Array<friend_id>  // For multi-friend events
+}
+```
+
+### Persistence Requirements
+- **MVP Password**: request browser-based classic password: "freehugs4all"
+- **Local Storage**: All data must persist between sessions
+- **Data Format**: Serialize Sets to Arrays for storage, reconstruct on load
+- **Auto-save**: Save on every state change, no manual save required
+
+## Feature Requirements
+
+### 1. Friends List View
+**Purpose**: Primary navigation and overview of all relationships
+
+**Implementation**:
+- Display all friends in scrollable list
+- Show metadata per friend: `{event_count} events · {connection_count} connections`
+- Click to navigate to friend detail view
+- Visual indicator (arrow/chevron) showing clickable items
+
+**Critical UX**:
+- Hover states for better interactivity feedback
+- Maintain scroll position when returning from detail view
+
+### 2. Friend Detail View
+**Purpose**: Manage individual friend's relationships and events
+
+**Layout**: Two-column design
+- Left column: Relationships management
+- Right column: Events timeline + add event form
+
+**Relationships Section**:
+- List ALL other friends with toggle switches
+- Toggle creates/removes bidirectional connection
+- **Critical Bug Fix**: Preserve scroll position during toggle operations
+  - Store scrollTop before state update
+  - Restore scrollTop after DOM update (use setTimeout or nextTick)
+- Show count in header: "Relationships (N)"
+
+**Events Section**:
+- Chronological list (newest first)
+- Display format: Date on top, notes below
+- Add Event form at bottom:
+  - Date picker (required)
+  - Multi-line text for notes (required)
+  - Submit button
+
+### 3. Events Tab (Timeline View)
+**Purpose**: Event-centric view for batch operations and timeline visualization
+
+**Components**:
+
+**New Event Creation**:
+- Quick date buttons: "Today", "Yesterday", "Week Ago", "Start of Month"
+- Multi-select friend list with:
+  - Search/filter box
+  - Checkbox per friend
+  - Visual highlight for selected friends
+  - Selected count display: "Friends (N selected)"
+- Optional location field
+- Required notes field
+- Create button disabled until friends selected AND notes entered
+
+**Timeline Display**:
+- Group events by date
+- Date headers with full format: "Monday, December 2, 2024"
+- Each event shows:
+  - Friend name (bold)
+  - Event notes
+  - Location with pin emoji if present
+- Visual hierarchy: Date > Friend > Details
+
+### 4. Orbits Visualization
+**Purpose**: Visual representation of relationship closeness based on interaction frequency
+
+**Layout**:
+- 3 concentric circles representing interaction levels
+- Center point at viewport center
+- Labels above each orbit
+
+**Orbit Assignment Logic**:
+```
+Last 90 days events count:
+- Inner orbit (5+ events): Close friends
+- Middle orbit (2-4 events): Regular friends  
+- Outer orbit (0-1 events): Distant friends
+```
+
+**Node Rendering**:
+- Distribute friends evenly around each orbit circumference
+- Angle calculation: `2π / friend_count` per orbit
+- Color coding by activity:
+  - Dark green (#2c5530): 5+ interactions
+  - Medium green (#5a9960): 2-4 interactions
+  - Light green (#a0c0a0): 0-1 interactions
+
+**Interactivity**:
+- **Click nodes** → Navigate to friend detail
+- **Hover** → Show tooltip with:
+  - Friend name (bold)
+  - Total events count
+  - Connection count
+  - Last 3 events with format: "DATE: first three words..."
+
+### 5. Network Graph
+**Purpose**: Visualize and edit relationship connections
+
+**Core Features**:
+- Force-directed graph layout
+- Node size proportional to connection count
+- Color intensity based on connections:
+  - 10+ connections: Dark green
+  - 5-9 connections: Medium green
+  - 1-4 connections: Light green
+  - 0 connections: Gray
+
+**Two Modes**:
+
+**View Mode** (default):
+- Click nodes → Navigate to friend detail
+- Drag nodes → Reposition
+- Scroll → Zoom
+- Drag canvas → Pan
+
+**Edit Mode** (toggled):
+- Visual indicator: Border color change + button state
+- Drag from node to node → Create/toggle connection
+- Connections are always bidirectional
+- Clear mode indicator: "Drag between nodes to create connections"
+
+**Critical Implementation**:
+- Node labels must be readable on all backgrounds:
+  - Use dark text (#333) always
+  - Add white stroke/outline for contrast
+- Physics simulation for organic clustering
+- Toggle physics on/off for performance
+
+## State Management Patterns
+
+### Data Flow
+1. **Single source of truth**: Main friends array
+2. **Derived states**: Calculate scores/orbits from events
+3. **Bidirectional updates**: When toggling relationships, update both friends
+
+### Update Triggers
+- Use update counter or key props to force re-renders after state changes
+- Critical for visualization updates after data modifications
+
+### Performance Optimizations
+- Memoize calculated values (interaction scores, event groupings)
+- Limit orbit calculations to last 90 days
+- Use Sets for relationship lookups (O(1) vs O(n))
+
+## Critical UX Patterns
+
+### Navigation Flow
+```
+Networks/Orbits (click node) → Set selected friend → Switch to List tab → Show detail
+```
+
+### Data Validation
+- Prevent self-relationships
+- Ensure bidirectional relationship consistency
+- Require notes for events (not just date)
+
+### Visual Feedback
+- Disabled states for invalid inputs
+- Active/hover states for all interactive elements
+- Loading states for data processing
+- Edit mode indicators
+
+## Statistics Dashboard
+Display four key metrics:
+1. **Connections**: Total unique relationships / 2 (bidirectional)
+2. **Active Friends**: Count with events in last 90 days
+3. **Total Events**: Sum of all events across all friends
+4. **Avg Events/Friend**: Total events / friend count
+
+## Data Import/Export Considerations
+
+### Reset Functionality
+- Confirm dialog before clearing
+- Complete localStorage wipe
+- Reinitialize with empty state
+
+### Future CSV Import
+Structure to support:
+```csv
+Name,Met_Date,Met_Location,Community,Last_Interaction,Next_Interaction,Location,Notes
+```
+
+Auto-categorization logic:
+- Rich profiles (notes + recent + future) → Inner circle
+- Some data → Middle circle
+- Minimal data → Outer circle
+
+## Technical Constraints & Solutions
+
+### Scroll Position Preservation
+**Problem**: React re-renders reset scroll position
+**Solution**: 
+```javascript
+const scrollTop = containerRef.current.scrollTop;
+updateState();
+setTimeout(() => {
+  containerRef.current.scrollTop = scrollTop;
+}, 0);
+```
+
+### Set Serialization
+**Problem**: Sets can't be JSON stringified
+**Solution**:
+```javascript
+// Save: Set → Array
+relationships: Array.from(friendSet)
+// Load: Array → Set
+relationships: new Set(savedArray)
+```
+
+### Graph Library Selection
+**Requirements**:
+- Force-directed layout
+- Interactive node positioning
+- Zoom/pan controls
+- Edit mode support
+- Custom node styling
+
+**Recommended features**:
+- Physics simulation
+- Collision detection
+- Touch support for mobile
+
+## Mobile Considerations
+- Touch-friendly tap targets (minimum 44x44px)
+- Swipe navigation between tabs
+- Responsive graph scaling
+- Bottom sheet pattern for add event form
+
+## Privacy & Security
+- All data stored locally only
+- No external API calls
+- No analytics or tracking
+- Clear data ownership messaging
+
+## Testing Checklist
+
+### Core Functionality
+- [ ] Add/remove bidirectional relationships
+- [ ] Create events with multiple participants
+- [ ] Navigate from graph nodes to details
+- [ ] Data persists after refresh
+- [ ] Scroll position maintained during updates
+
+### Edge Cases
+- [ ] 0 friends state
+- [ ] 0 events state  
+- [ ] Maximum friends (150+) performance
+- [ ] Circular relationship consistency
+- [ ] Date boundary conditions
+
+### Visual Validation
+- [ ] Orbit distribution is even
+- [ ] Network labels readable on all backgrounds
+- [ ] Edit mode clearly indicated
+- [ ] Responsive on various screen sizes
+
+## Implementation Order (Recommended)
+
+1. **Data Layer**: Models, storage, state management
+2. **Friends List**: Basic CRUD, detail view
+3. **Events System**: Single friend events first
+4. **Persistence**: LocalStorage integration
+5. **Orbits View**: Calculate positions, render, tooltips
+6. **Network Graph**: Basic visualization
+7. **Multi-friend Events**: Batch selection UI
+8. **Network Editing**: Drag-to-connect functionality
+9. **Polish**: Animations, performance, mobile
+
+## Success Metrics
+- Users can manage 150 relationships without performance degradation
+- All state changes persist and sync across views
+- Visual representations update in real-time
+- Edit operations feel intuitive without instructions
+- Data remains private and under user control
+
+---
+
+*This guide represents a validated MVP feature set. Focus on core functionality before adding enhancements.*
\ No newline at end of file

next/pages/dunbar/index.js

+import Head from 'next/head';
+import Layout from '@/components/layout';
+import DunbarApp from '@/components/dunbar/DunbarApp';
+
+export default function DunbarPage() {
+  return (
+    <div className="container">
+      <Layout>
+        <Head>
+          <title>Dunbar — Relationship Navigator</title>
+          <meta name="robots" content="noindex" />
+        </Head>
+        <DunbarApp />
+      </Layout>
+    </div>
+  );
+}

next/styles/dunbar.module.css

+/* Dunbar MVP styles (scoped via CSS Modules) */
+
+.container {
+  padding: 16px;
+  max-width: 1200px;
+  margin: 0 auto;
+}
+
+.header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.title {
+  font-size: 1.5rem;
+  font-weight: 700;
+}
+
+.row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.spacer {
+  flex: 1;
+}
+
+.tabs {
+  display: flex;
+  gap: 8px;
+  margin: 8px 0 16px;
+  flex-wrap: wrap;
+}
+
+.tabBtn {
+  padding: 8px 12px;
+  border: 1px solid #ddd;
+  background: #fafafa;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: background 120ms ease, border-color 120ms ease;
+}
+
+.tabBtn:hover {
+  background: #f0f0f0;
+}
+
+.tabActive {
+  background: #e7f5ec;
+  border-color: #5a9960;
+}
+
+.toolbar {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  margin-bottom: 12px;
+  flex-wrap: wrap;
+}
+
+.input, .textarea, .select {
+  border: 1px solid #ddd;
+  border-radius: 8px;
+  padding: 8px 10px;
+  font-size: 0.95rem;
+  background: #fff;
+}
+
+.textarea {
+  min-height: 80px;
+  resize: vertical;
+}
+
+.btn {
+  padding: 8px 12px;
+  border: 1px solid #222;
+  background: #222;
+  color: #fff;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: background 120ms ease, opacity 120ms ease;
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.btnSecondary {
+  padding: 8px 12px;
+  border: 1px solid #ddd;
+  background: #fff;
+  color: #333;
+  border-radius: 8px;
+  cursor: pointer;
+}
+
+.list {
+  border: 1px solid #eee;
+  border-radius: 10px;
+  overflow: hidden;
+}
+
+.listScroll {
+  max-height: 60vh;
+  overflow: auto;
+}
+
+.listItem {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 12px;
+  border-bottom: 1px solid #f2f2f2;
+  cursor: pointer;
+  background: #fff;
+  transition: background 120ms ease;
+}
+
+.listItem:hover {
+  background: #f9f9f9;
+}
+
+.itemTitle {
+  font-weight: 600;
+}
+
+.itemMeta {
+  color: #666;
+  font-size: 0.9rem;
+}
+
+.itemRight {
+  margin-left: auto;
+  color: #aaa;
+}
+
+.twoCol {
+  display: grid;
+  grid-template-columns: 1fr 1.4fr;
+  gap: 16px;
+}
+
+@media (max-width: 900px) {
+  .twoCol {
+    grid-template-columns: 1fr;
+  }
+}
+
+.card {
+  border: 1px solid #eee;
+  background: #fff;
+  border-radius: 10px;
+  padding: 12px;
+}
+
+.cardHeader {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 8px;
+  font-weight: 600;
+}
+
+.scroll {
+  max-height: 60vh;
+  overflow: auto;
+}
+
+.switchRow {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 6px;
+  border-bottom: 1px solid #f5f5f5;
+}
+
+.switchRow:hover {
+  background: #fafafa;
+}
+
+.switch {
+  width: 42px;
+  height: 24px;
+  background: #ddd;
+  border-radius: 999px;
+  position: relative;
+  transition: background 120ms ease;
+}
+
+.switchOn {
+  background: #5a9960;
+}
+
+.knob {
+  position: absolute;
+  top: 3px;
+  left: 3px;
+  width: 18px;
+  height: 18px;
+  background: #fff;
+  border-radius: 50%;
+  transition: left 120ms ease;
+  box-shadow: 0 1px 2px rgba(0,0,0,0.15);
+}
+
+.knobOn {
+  left: 21px;
+}
+
+.timeline {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.timelineGroup {
+  margin: 8px 0;
+}
+
+.timelineDate {
+  font-weight: 700;
+  margin-bottom: 6px;
+}
+
+.timelineEvent {
+  background: #fbfbfb;
+  border: 1px solid #f0f0f0;
+  border-radius: 8px;
+  padding: 8px 10px;
+}
+
+.badge {
+  display: inline-block;
+  padding: 2px 6px;
+  border-radius: 999px;
+  background: #eef7f0;
+  color: #2c5530;
+  font-size: 0.8rem;
+  border: 1px solid #d6e8da;
+}
+
+.tooltip {
+  position: fixed;
+  background: #fff;
+  border: 1px solid #eee;
+  border-radius: 8px;
+  padding: 8px 10px;
+  box-shadow: 0 8px 24px rgba(0,0,0,0.08);
+  pointer-events: none;
+  z-index: 1000;
+  max-width: 280px;
+  font-size: 0.9rem;
+}
+
+.graphToolbar {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  margin-bottom: 8px;
+  flex-wrap: wrap;
+}
+
+.banner {
+  padding: 8px 10px;
+  background: #fffbea;
+  border: 1px solid #fde68a;
+  color: #7c5e10;
+  border-radius: 8px;
+}
+
+.statsGrid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(140px, 1fr));
+  gap: 12px;
+}
+
+@media (max-width: 700px) {
+  .statsGrid {
+    grid-template-columns: repeat(2, minmax(140px, 1fr));
+  }
+}
+
+.statCard {
+  border: 1px solid #eee;
+  background: #fff;
+  border-radius: 10px;
+  padding: 12px;
+}
+
+.statLabel {
+  color: #666;
+  font-size: 0.9rem;
+}
+
+.statValue {
+  font-size: 1.6rem;
+  font-weight: 800;
+}
+
+/* Orbits */
+.orbitsWrap {
+  width: 100%;
+  height: 70vh;
+  border: 1px solid #eee;
+  border-radius: 10px;
+  overflow: hidden;
+  background: radial-gradient(circle at center, #ffffff 0%, #f7fbf8 100%);
+}
+
+.orbitLabel {
+  fill: #2c5530;
+  font-size: 12px;
+  font-weight: 700;
+}
+
+.nodeLabel {
+  fill: #333;
+  font-weight: 700;
+  paint-order: stroke;
+  stroke: #fff;
+  stroke-width: 3px;
+  stroke-linejoin: round;
+}
+
+/* Network */
+.canvasWrap {
+  width: 100%;
+  height: 70vh;
+  border: 1px solid #eee;
+  border-radius: 10px;
+  overflow: hidden;
+  background: #fff;
+}
+
+.chevron {
+  font-size: 14px;
+  color: #999;
+}
+
+/* Password screen */
+.lockWrap {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 50vh;
+  flex-direction: column;
+  gap: 10px;
+  text-align: center;
+}