Frontend in Svelte

.dockerignore

···
-target
+*/target
 **/target
 **/.idea
 .idea
-.env
+.env
+*/node_modules

Cargo.lock

···
 checksum = "d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"
 
 [[package]]
-name = "askama"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f75363874b771be265f4ffe307ca705ef6f3baa19011c149da8674a87f1b75c4"
-dependencies = [
- "askama_derive",
- "itoa",
- "percent-encoding",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "askama_derive"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "129397200fe83088e8a68407a8e2b1f826cf0086b21ccdb866a722c8bcd3a94f"
-dependencies = [
- "askama_parser",
- "basic-toml",
- "memchr",
- "proc-macro2",
- "quote",
- "rustc-hash",
- "serde",
- "serde_derive",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "askama_parser"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6ab5630b3d5eaf232620167977f95eb51f3432fc76852328774afbd242d4358"
-dependencies = [
- "memchr",
- "serde",
- "serde_derive",
- "winnow 0.7.13",
-]
-
-[[package]]
 name = "async-compression"
 version = "0.4.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba"
 
 [[package]]
-name = "basic-toml"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
-dependencies = [
- "serde",
-]
-
-[[package]]
 name = "bigdecimal"
 version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "chrono",
  "once_cell",
- "winnow 0.6.26",
+ "winnow",
 ]
 
 [[package]]
···
  "apalis",
  "apalis-cron",
  "apalis-sql",
- "chrono",
  "dotenvy",
  "log",
- "serde",
  "shared",
  "tokio",
  "tower",
- "tracing",
  "tracing-subscriber",
 ]
 
···
  "dotenvy",
  "env_logger",
  "jacquard",
- "jacquard-api",
  "jacquard-common",
  "lexicon_types_crate",
  "log",
  "reqwest",
+ "rust-s3",
+ "shared",
+ "sqlx",
  "tokio",
 ]
 
···
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
-name = "vite-rust"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae9a5cd007a52d1227f4de7488c9da0a46b7946b3e9803025677e797ffe6f41"
-dependencies = [
- "hex",
- "log",
- "md-5",
- "regex",
- "reqwest",
- "serde",
- "serde_json",
-]
-
-[[package]]
 name = "walkdir"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "anyhow",
  "apalis",
  "apalis-sql",
- "askama",
  "async-compression",
  "atproto-identity",
  "axum",
···
  "tower_governor",
  "tracing",
  "tracing-subscriber",
- "vite-rust",
 ]
 
 [[package]]
···
 version = "0.6.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e90edd2ac1aa278a5c4599b1d89cf03074b610800f866d4026dc199d7929a28"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "winnow"
-version = "0.7.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
  "memchr",
 ]

Dockerfiles/web-ui.Dockerfile

···
+FROM node:24-slim as builder
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable
+WORKDIR /app
+
+COPY ./web-ui /app
+RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install
+RUN pnpm run build
+
+FROM node:24-alpine3.22 as web-ui
+WORKDIR /app
+
+COPY --from=builder /app/build /app/build
+COPY --from=builder /app/package*.json /app/
+RUN npm install --omit=dev
+
+CMD ["node", "build"]

Dockerfiles/web.Dockerfile

···
-FROM node:24-alpine3.21 as node_builder
-WORKDIR /app
-
-COPY ./web/ui-code/ /app
-#Not a fan of the --force here
-RUN npm install --force
-RUN npm run build
-
 FROM rust:1.90.0-bookworm AS builder
 WORKDIR /app
 COPY . /app
 RUN cargo build --bin web --release
 
 FROM rust:1.90.0-bookworm AS web
-COPY --from=node_builder /app/dist /app/vite/dist
-COPY ./web/public /app/public
 COPY --from=builder /app/target/release/web /usr/local/bin/web
 
 CMD ["web"]

ProductionComposes/Caddyfile

···
+:80 {
+	@xrpc {
+		path /xrpc/*
+		path /.well-known/*
+	}
+
+	# Handle /xrpc/ routes - forward to the API backend (web service)
+	handle @xrpc {
+		reverse_proxy localhost:3000
+	}
+
+	# Handle all other routes - forward to the web-ui frontend
+	handle /* {
+		reverse_proxy localhost:3001
+	}
+}

ProductionComposes/compose.web.yml

···
 services:
   web:
     image: fatfingers23/moover_web:latest
-    network_mode: host
     restart: unless-stopped
+    network_mode: host
     ports:
       - "3000:3000"
     env_file:
···
     environment:
       - VITE_DIST=/app/vite/dist
       - PUBLIC_ASSETS=/app/public
+  web-ui:
+    image: fatfingers23/moover_ui:latest
+    network_mode: host
+    restart: unless-stopped
+    ports:
+      - "3001:3001"
+    environment:
+      - PORT=3001
+      - PUBLIC_XRPC_BASE=pdsmoover.com
+  caddy:
+    image: caddy:2-alpine
+    network_mode: host
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./Caddyfile:/etc/caddy/Caddyfile
+      - caddy_data:/data
+      - caddy_config:/config
+    depends_on:
+      - web
+      - web-ui
   #Only a single one of these instances should be running
   #it's what triggers daily backups
   cron-worker:
     image: fatfingers23/moover_cron_worker:latest
     network_mode: host
+    restart: unless-stopped
     build:
       context: .
       dockerfile: ./Dockerfiles/cron-worker.Dockerfile
     env_file:
       - path: .env
-        required: true
+        required: true
+
+networks:
+  moover_network:
+    driver: bridge
+
+volumes:
+  caddy_data:
+  caddy_config:

ProductionComposes/compose.workers.yml

···
   worker-two:
     image: fatfingers23/moover_worker:latest
     network_mode: host
+    restart: unless-stopped
     env_file:
       - path: .env
         required: true
···
   worker-three:
     image: fatfingers23/moover_worker:latest
     network_mode: host
+    restart: unless-stopped
     env_file:
       - path: .env
         required: true

README.md

···
 A series of web tools to help users: migrate to a new PDS, find missing blobs, have free backups, and restore from
 backups in the event of emergency. [pdsmoover.com](https://pdsmoover.com)
 
-![cow](./web/public/halloween_moover.webp)
+![cow](./web-ui/src/lib/assets/moo.webp)
 
 A little light on documentation as I come off of about a week long crunch but.
 
···
 - [cron-worker](./cron-worker) - Very simple binary to tick every hour telling the main worker to check for repos that
   need an update
 - [Dockerfiles](./Dockerfiles) - Dockerfiles for all the services in the repo
-- [lexicon_types](./lexicon_types) - TypeScript types for PDS MOOver lexicons (not currently in use)
+- [packages/lexicons](./packages/lexicons) - TypeScript types for PDS MOOver lexicons
+- [packages/moover](./packages/moover) - Frontend logic that handles all the atproto processes. Also published as a node
+  module
+  at [@pds-moover/moover](https://www.npmjs.com/package/@pds-moover/moover)
 - [lexicon_types_crate](./lexicon_types_crate) - Rust lexicon types
 - [lexicons](./lexicons) - JSON Lexicons
 - [ProductionComposes](./ProductionComposes) - What I use to run PDS MOOver in production. One instance of web behind a
   load balancer, one worker node currently with 3 instances on that one server. All can scale horizontally
 - [shared](./shared) - Shared code between all the services
 - [web](./web) - The web frontend that servers XRPC endpoints and the frontend
-- [web-ui](./web/ui-code) - JS code to handle everything to do with atproto such as Migrations, missing blobs, signing
+- [web-ui](./web-ui) - Svelte frontend.
   plc ops, restores, etc
 - [worker](./worker) - What acutally handles all the backing up, but the actual logic is
   in [./shared/src/jobs/](./shared/src/jobs/)

admin_cli/Cargo.toml

···
 env_logger = "0.11"
 tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
 jacquard-common.workspace = true
-jacquard-api.workspace = true
 jacquard.workspace = true
 lexicon_types_crate.workspace = true
 reqwest.workspace = true
-base64 = "0.22"
+base64 = "0.22"
+shared = { path = "../shared" }
+sqlx = { version = "0.8.6", features = ["runtime-tokio", "postgres"] }
+rust-s3.workspace = true

admin_cli/src/main.rs

···
 use log;
 use reqwest::header;
 use reqwest::header::{HeaderMap, HeaderValue};
+use s3::creds::Credentials;
+use s3::{Bucket, Region};
+use sqlx::PgPool;
 use std::env;
 
 fn init_logging() {
···
     },
     /// Trigger an instance-wide backup job (no parameters)
     RequestInstanceBackup,
+    /// Verify all backups in S3 against the database
+    VerifyBackups,
 }
 
 #[derive(Debug, Subcommand)]
···
                 }
                 Err(err) => {
                     log::error!("Instance backup request failed: {}", err);
+                }
+            }
+        }
+        Commands::VerifyBackups => {
+            //Not really a part of the cli per say. But I needed it and is a good place as any
+            log::info!("Verifying backups in S3...");
+
+            // Get database URL from environment
+            let database_url =
+                env::var("DATABASE_URL").context("DATABASE_URL environment variable not set")?;
+
+            // Connect to database
+            let pool = PgPool::connect(&database_url)
+                .await
+                .context("Failed to connect to database")?;
+
+            // Setup S3 client
+            let region_name = env::var("S3_REGION")?;
+            let endpoint = env::var("S3_ENDPOINT")?;
+            let region = Region::Custom {
+                region: region_name,
+                endpoint,
+            };
+            let bucket = Bucket::new(
+                env::var("S3_BUCKET_NAME")?.as_str(),
+                region,
+                Credentials::new(
+                    Some(env::var("S3_ACCESS_KEY")?.as_str()),
+                    Some(env::var("S3_SECRET_KEY")?.as_str()),
+                    None,
+                    None,
+                    None,
+                )?,
+            )?;
+
+            // Call the verify_backups function
+            match shared::jobs::verify_backups::verify_backups(&pool, &bucket).await {
+                Ok(missing_blobs) => {
+                    if missing_blobs.is_empty() {
+                        log::info!("✓ All backups verified successfully! No missing blobs found.");
+                    } else {
+                        log::error!("✗ Found {} missing blobs:", missing_blobs.len());
+                        for missing in &missing_blobs {
+                            println!(
+                                "Missing: DID={}, CID/REV={}, TYPE={:?}, PATH={}",
+                                missing.did, missing.cid_or_rev, missing.blob_type, missing.s3_path
+                            );
+                        }
+                    }
+                }
+                Err(err) => {
+                    log::error!("Failed to verify backups: {}", err);
                 }
             }
         }

compose.dev.yml

···
 services:
   postgres:
-    image: postgres:latest
+    image: postgres:18
     restart: unless-stopped
     environment:
       POSTGRES_USER: ${DB_USER}
···
     ports:
       - "5432:5432"
     volumes:
-      - moove-postgres-data:/var/lib/postgresql/data
+      - moove-postgres-data:/var/lib/postgresql
     extra_hosts:
       - "host.docker.internal:host-gateway"
     networks:

compose.selfhost.yml

···
       - PUBLIC_ASSETS=/app/public
     depends_on:
       - postgres
+  web-ui:
+    #    image: fatfingers23/moover_web_ui:latest
+    build:
+      context: .
+      dockerfile: ./Dockerfiles/web-ui.Dockerfile
+    ports:
+      - "3001:3001"
+    env_file:
+      - path: .env
+        required: false
+    environment:
+      - PORT=3001
+    networks:
+      - moover-network
   cron-worker:
     image: fatfingers23/moover_cron_worker:latest
     #    build:

cron-worker/Cargo.toml

···
 apalis-sql.workspace = true
 apalis-cron.workspace = true
 dotenvy.workspace = true
-tracing.workspace = true
 tracing-subscriber.workspace = true
 shared.workspace = true
 log.workspace = true
-serde.workspace = true
-chrono.workspace = true
 tower = { version = "0.5.2", features = ["load-shed"] }
 tokio.workspace = true

justfile

···
     docker buildx build \
             --platform linux/arm64,linux/amd64 \
             --tag fatfingers23/moover_web:latest \
-            --tag fatfingers23/moover_web:0.0.1 \
+            --tag fatfingers23/moover_web:0.0.2 \
             --file Dockerfiles/web.Dockerfile \
             --push .
     # Worker
     docker buildx build \
             --platform linux/arm64,linux/amd64 \
             --tag fatfingers23/moover_worker:latest \
-            --tag fatfingers23/moover_worker:0.0.1 \
+            --tag fatfingers23/moover_worker:0.0.2 \
             --file Dockerfiles/worker.Dockerfile \
             --push .
     #cron worker
     docker buildx build \
            --platform linux/arm64,linux/amd64 \
            --tag fatfingers23/moover_cron_worker:latest \
-           --tag fatfingers23/moover_cron_worker:0.0.1 \
+           --tag fatfingers23/moover_cron_worker:0.0.2 \
            --file Dockerfiles/cron-worker.Dockerfile \
+            --push .
+
+    #web ui
+    docker buildx build \
+           --platform linux/arm64,linux/amd64 \
+           --tag fatfingers23/moover_ui:latest \
+           --tag fatfingers23/moover_ui:0.0.2 \
+           --file Dockerfiles/web-ui.Dockerfile \
             --push .

lexicon_types/lex.config.js packages/lexicons/lex.config.js

···
 import {defineLexiconConfig} from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-    files: ['../lexicons/**/*.json'],
-    outdir: 'src/'
+    files: ['../../lexicons/**/*.json'],
+    outdir: 'lib/lexicons'
 });

lexicon_types/package.json

···
-{
-  "name": "@pds-moover/lexicon_types",
-  "version": "0.0.0",
-  "type": "module",
-  "main": "./dist/lexicon_types.umd.cjs",
-  "module": "./dist/lexicon_types.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/lexicon_types.js",
-      "require": "./dist/lexicon_types.umd.cjs"
-    }
-  },
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc && vite build",
-    "preview": "vite preview"
-  },
-  "devDependencies": {
-    "@atcute/lex-cli": "^2.2.2",
-    "@types/node": "^24.7.2",
-    "typescript": "~5.9.3",
-    "vite": "^7.1.7",
-    "vite-plugin-dts": "^4.5.4"
-  },
-  "dependencies": {
-    "@atproto/lexicon": "^0.5.1",
-    "@atproto/xrpc": "^0.7.5",
-    "cid": "multiformats/cid"
-  }
-}

lexicon_types/src/types/com/pdsmoover/admin/requestBackup.ts

···
-import type {} from "@atcute/lexicons";
-import * as v from "@atcute/lexicons/validations";
-import type {} from "@atcute/lexicons/ambient";
-
-const _mainSchema = /*#__PURE__*/ v.procedure(
-  "com.pdsmoover.admin.requestBackup",
-  {
-    params: null,
-    input: null,
-    output: null,
-  },
-);
-
-type main$schematype = typeof _mainSchema;
-
-export interface mainSchema extends main$schematype {}
-
-export const mainSchema = _mainSchema as mainSchema;
-
-export interface $params {}
-
-declare module "@atcute/lexicons/ambient" {
-  interface XRPCProcedures {
-    "com.pdsmoover.admin.requestBackup": mainSchema;
-  }
-}

lexicon_types/tsconfig.json

···
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "useDefineForClassFields": true,
-    "module": "ESNext",
-    "lib": [
-      "ES2022",
-      "DOM",
-      "DOM.Iterable"
-    ],
-    "types": [
-      "vite/client"
-    ],
-    "skipLibCheck": true,
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  },
-  "include": [
-    "src"
-  ]
-}

lexicon_types/vite.config.ts

···
-import {resolve} from 'path';
-import {defineConfig} from 'vite';
-import dts from 'vite-plugin-dts';
-
-// https://vitejs.dev/guide/build.html#library-mode
-export default defineConfig({
-    build: {
-        lib: {
-            entry: resolve(__dirname, 'src/index.ts'),
-            name: 'lexicon_types',
-            fileName: 'lexicon_types',
-        },
-    },
-    plugins: [dts()],
-});

packages/lexicons/lib/index.ts

···
+export * from './lexicons/index.js'

packages/lexicons/package.json

···
+{
+  "type": "module",
+  "name": "@pds-moover/lexicons",
+  "description": "PDS MOOver Lexicon Types",
+  "version": "1.0.1",
+  "license": "MIT",
+  "repository": "https://tangled.org/@baileytownsend.dev/pds-moover",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./types/*": "./dist/lexicons/types/sh/tangled/*.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
+    "prepublishOnly": "rm -rf dist; npm run build"
+  },
+  "devDependencies": {
+    "@atcute/lex-cli": "^2.2.2"
+  },
+  "dependencies": {
+    "@atproto/lexicon": "^0.5.1",
+    "@atproto/xrpc": "^0.7.5"
+  }
+}

packages/lexicons/tsconfig.json

···
+{
+  "compilerOptions": {
+    "outDir": "dist/",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "target": "ESNext",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "NodeNext",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": [
+    "lib"
+  ]
+}

packages/moover/.npmrc

···
+@atpkgs:registry=https://registry.atpkgs.easrng.net/

packages/moover/README.md

···
+# @pds-moover/moover
+
+![cow](./images/moo.webp)
+
+This is the core logic that runs [PDS MOOver](https://pdsmoover.com). With this you should be able to create your own
+"PDS MOOver" without having
+to figure out the atproto logic.
+
+- [lib/atprotoUtils.js](./lib/atprotoUtils.js) - Helpers for atproto actions
+- [Migrator](./lib/pdsmoover.js) - For handling regular migrations
+- [BackupService](./lib/backup.js) - For signing up for backups, request a back up, and remove backups to a PDS MOOver
+  instance
+- [MissingBlobs](./lib/missingBlobs.js) - Finds missing blobs on your old PDS and uploads them to your new PDS
+- [PlcOps](./lib/plc-ops.js) - Helpers for manual PCL operations
+- [Restore](./lib/restore.js) - Handles a recovery and restores the at proto from the backup

packages/moover/index.html

···
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8"/>
+    <link rel="icon" type="image/svg+xml" href="/vite.svg"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+    <title>moover</title>
+</head>
+<body>
+<div id="app"></div>
+<script type="module" src="/lib/main.js"></script>
+</body>
+</html>

packages/moover/lib/atprotoUtils.js

···
+import {
+    CompositeDidDocumentResolver, CompositeHandleResolver,
+    DohJsonHandleResolver,
+    PlcDidDocumentResolver, WebDidDocumentResolver,
+    WellKnownHandleResolver
+} from '@atcute/identity-resolver';
+
+const handleResolver = new CompositeHandleResolver({
+    strategy: 'race',
+    methods: {
+        dns: new DohJsonHandleResolver({
+            dohUrl: 'https://mozilla.cloudflare-dns.com/dns-query',
+        }),
+        http: new WellKnownHandleResolver(),
+    },
+});
+
+const docResolver = new CompositeDidDocumentResolver({
+    methods: {
+        plc: new PlcDidDocumentResolver(),
+        web: new WebDidDocumentResolver(),
+    },
+});
+
+/**
+ * Cleans the handle of @ and some other unicode characters that used to show up when copied from the profile
+ * @param handle {string}
+ * @returns {string}
+ */
+const cleanHandle = (handle) =>
+    handle.replace('@', '').trim().replace(
+        /[\u202A\u202C\u200E\u200F\u2066-\u2069]/g,
+        '',
+    );
+
+
+/**
+ *  Convince helper to resolve a handle to a did and then find the PDS url from the did document.
+ *
+ * @param handle
+ * @returns {Promise<{usersDid: string, pds: string}>}
+ */
+async function handleAndPDSResolver(handle) {
+    let usersDid = null;
+    if (handle.startsWith('did:')) {
+        usersDid = handle;
+    } else {
+        const cleanedHandle = cleanHandle(handle);
+        usersDid = await handleResolver.resolve(cleanedHandle);
+    }
+    const didDoc = await docResolver.resolve(usersDid);
+
+    let pds;
+    try {
+        pds = didDoc.service?.filter((s) =>
+            s.type === 'AtprotoPersonalDataServer'
+        )[0].serviceEndpoint;
+    } catch (error) {
+        throw new Error('Could not find a PDS in the DID document.');
+    }
+    return {usersDid, pds};
+}
+
+
+/**
+ *  Fetches the DID Web from the .well-known/did.json endpoint of the server.
+ *  Legacy and was helpful if the web ui and server are on the same domain, not as useful now
+ * @param baseUrl
+ * @returns {Promise<*>}
+ */
+async function fetchPDSMooverDIDWeb(baseUrl) {
+    const response = await fetch(`${baseUrl}/.well-known/did.json`);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch DID document: ${response.status}`);
+    }
+    const didDoc = await response.json();
+    return didDoc.id;
+}
+
+
+export {handleResolver, docResolver, cleanHandle, handleAndPDSResolver, fetchPDSMooverDIDWeb};

packages/moover/lib/backup.js

···
+import {Client, CredentialManager, ok} from '@atcute/client';
+import {handleAndPDSResolver} from './atprotoUtils.js';
+//Shows as unused, but is used in the return types
+import {ComPdsmooverBackupDescribeServer} from '@pds-moover/lexicons';
+
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ * @typedef {import('@atcute/lexicons').InferXRPCBodyOutput} InferXRPCBodyOutput
+ */
+
+
+/**
+ * Logic to sign up and manage backups for pdsmoover.com (or your own selfhosted instance)
+ */
+class BackupService {
+    /**
+     *
+     * @param backupDidWeb {string} - The did:web for the xrpc service for backups, defaults to did:web:pdsmoover.com
+     */
+    constructor(backupDidWeb = 'did:web:pdsmoover.com') {
+        /**
+         *
+         * @type {Client}
+         */
+        this.atCuteClient = null;
+        /**
+         *
+         * @type {CredentialManager}
+         */
+        this.atCuteCredentialManager = null;
+
+        /**
+         * The did:web for the xrpc service for backups, defaults to pdsmoover.com
+         * @type {string}
+         */
+        this.backupDidWeb = backupDidWeb;
+    }
+
+
+    /**
+     *  Logs in and returns the backup status.
+     *  To use the rest of the BackupService, it is assumed that this has ran first,
+     *  and the user has successfully signed up. A successful login is a returned null if the user has not signed up.
+     *  or the backup status if they are
+     *
+     *  If the server requires 2FA,
+     *  it will throw with error.error === 'AuthFactorTokenRequired'.
+     * @param identifier {string} handle or did
+     * @param password {string}
+     * @param {function|null} onStatus - a function that takes a string used to update the UI.
+     * Like (status) => console.log(status)
+     * @param twoFactorCode {string|null}
+     *
+     * @returns {Promise<InferXRPCBodyOutput<ComPdsmooverBackupDescribeServer.mainSchema['output']>|null>}
+     */
+    async loginAndStatus(identifier, password, onStatus = null, twoFactorCode = null) {
+        let {pds} = await handleAndPDSResolver(identifier);
+
+
+        const manager = new CredentialManager({
+            service: pds
+        });
+
+
+        const rpc = new Client({
+            handler: manager,
+            proxy: {
+                did: this.backupDidWeb,
+                serviceId: '#repo_backup'
+            }
+        });
+
+        try {
+            if (onStatus) onStatus('Signing in…');
+
+            let loginInput = {
+                identifier,
+                password,
+
+            };
+            if (twoFactorCode) {
+                loginInput.code = twoFactorCode;
+            }
+            await manager.login(loginInput);
+
+
+            // Make the client/manager available regardless of repo status so we can sign up if needed.
+            this.atCuteClient = rpc;
+            this.atCuteCredentialManager = manager;
+
+            if (onStatus) onStatus('Checking backup status');
+            const result = await rpc.get('com.pdsmoover.backup.getRepoStatus', {
+                params: {
+                    did: manager.session.did.toString()
+                }
+            });
+            if (result.ok) {
+                return result.data;
+            } else {
+                switch (result.data.error) {
+                    case 'RepoNotFound':
+                        return null;
+                    default:
+                        throw result.data.error;
+                }
+
+            }
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    /**
+     * Signs the user up for backups with the service
+     * @param onStatus
+     * @returns {Promise<void>}
+     */
+    async signUp(onStatus = null) {
+        if (!this.atCuteClient || !this.atCuteCredentialManager) {
+            throw new Error('Not signed in');
+        }
+        if (onStatus) onStatus('Creating backup registration…');
+        await ok(
+            this.atCuteClient.post('com.pdsmoover.backup.signUp', {
+                as: null,
+            })
+        );
+        if (onStatus) onStatus('Backup registration complete');
+        //No return if successful
+    }
+
+    /**
+     * Requests a PLC token to be sent to the user's email, needed to add a new rotation key
+     * @returns {Promise<void>}
+     */
+    async requestAPlcToken() {
+        if (!this.atCuteClient || !this.atCuteCredentialManager) {
+            throw new Error('Not signed in');
+        }
+        const rpc = new Client({
+            handler: this.atCuteCredentialManager,
+        });
+
+        let response = await rpc.post('com.atproto.identity.requestPlcOperationSignature', {
+            as: null,
+        });
+        if (!response.ok) {
+            throw new Error(response.data?.message || 'Failed to request PLC token');
+        }
+    }
+
+    /**
+     *  Adds a new rotation to the users did document. Assumes you are already signed in.
+     *
+     *  WARNING: This will overwrite any existing rotation keys with the new one at the top, and the PDS key as the second one
+     * @param plcToken {string} - PLC token from the user's email that was sent from requestAPlcToken
+     * @param rotationKey {string} - The new rotation key to add to the user's did document
+     * @returns {Promise<void>}
+     */
+    async addANewRotationKey(plcToken, rotationKey) {
+        if (!this.atCuteClient || !this.atCuteCredentialManager) {
+            throw new Error('Not signed in');
+        }
+
+
+        const rpc = new Client({
+            handler: this.atCuteCredentialManager,
+        });
+
+        let getDidCredentials = await rpc.get('com.atproto.identity.getRecommendedDidCredentials');
+
+        if (getDidCredentials.ok) {
+            const pdsProvidedRotationKeys = getDidCredentials.data.rotationKeys ?? [];
+            const updatedRotationKeys = [rotationKey, ...pdsProvidedRotationKeys];
+
+            const credentials = {
+                ...getDidCredentials.data,
+                rotationKeys: updatedRotationKeys,
+            };
+
+            const signDocRes = await rpc.post('com.atproto.identity.signPlcOperation', {
+                input: {
+                    token: plcToken,
+                    ...credentials,
+                }
+            });
+
+            if (signDocRes.ok) {
+                const submitDocRes = await rpc.post('com.atproto.identity.submitPlcOperation', {
+                    input: signDocRes.data,
+                    as: null,
+                });
+
+                if (!submitDocRes.ok) {
+                    throw new Error(submitDocRes.data?.message || 'Failed to submit PLC operation');
+                }
+
+            } else {
+                throw new Error(signDocRes.data?.message || 'Failed to sign PLC operation');
+            }
+
+
+        } else {
+            throw new Error(getDidCredentials.data?.message || 'Failed to get status');
+        }
+    }
+
+
+    /**
+     *
+     *  Gets the current status of the user's backup repository.
+     *
+     * @param onStatus {function|null} - a function that takes a string used to update the UI.
+     * @returns {Promise<InferXRPCBodyOutput<ComPdsmooverBackupDescribeServer.mainSchema['output']>>}
+     */
+    async getUsersRepoStatus(onStatus = null) {
+        if (!this.atCuteClient || !this.atCuteCredentialManager) {
+            throw new Error('Not signed in');
+        }
+        if (onStatus) onStatus('Refreshing backup status…');
+        const result = await this.atCuteClient.get('com.pdsmoover.backup.getRepoStatus', {
+            params: {did: this.atCuteCredentialManager.session.did.toString()}
+        });
+        if (result.ok) {
+            return result.data;
+        } else {
+            throw new Error(result.data?.message || 'Failed to get status');
+        }
+    }
+
+    /**
+     * Requests a backup to be run immediately for the signed-in user. Usually does, depend on the server's backup queue
+     * @param onStatus
+     * @returns {Promise<boolean>}
+     */
+    async runBackupNow(onStatus = null) {
+        if (!this.atCuteClient || !this.atCuteCredentialManager) {
+            throw new Error('Not signed in');
+        }
+        if (onStatus) onStatus('Requesting backup…');
+        const res = await this.atCuteClient.post('com.pdsmoover.backup.requestBackup', {as: null, data: {}});
+        if (res.ok) {
+            if (onStatus) onStatus('Backup requested.');
+            return true;
+        } else {
+            const err = res.data;
+            if (err?.error === 'Timeout') {
+                throw {error: 'Timeout', message: err?.message || 'Please wait a few minutes before requesting again.'};
+            }
+            throw new Error(err?.message || 'Failed to request backup');
+        }
+    }
+
+    /**
+     * Remove (delete) the signed-in user's backup repository. this also deletes all the user's backup data.
+     * @param onStatus
+     * @returns {Promise<boolean>}
+     */
+    async removeRepo(onStatus = null) {
+        if (!this.atCuteClient || !this.atCuteCredentialManager) {
+            throw new Error('Not signed in');
+        }
+        if (onStatus) onStatus('Deleting backup repository…');
+        const res = await this.atCuteClient.post('com.pdsmoover.backup.removeRepo', {as: null, data: {}});
+        if (res.ok) {
+            if (onStatus) onStatus('Backup repository deleted.');
+            return true;
+        } else {
+            const err = res.data;
+            throw new Error(err?.message || 'Failed to delete backup repository');
+        }
+    }
+}
+
+
+export {BackupService};

packages/moover/lib/main.js

···
+import {Migrator} from './pdsmoover.js';
+import {MissingBlobs} from './missingBlobs.js';
+import {BackupService} from './backup.js';
+import {PlcOps} from './plc-ops.js';
+import {Restore} from './restore.js';
+import {handleAndPDSResolver} from './atprotoUtils.js';
+
+export {
+    Migrator,
+    MissingBlobs,
+    BackupService,
+    PlcOps,
+    Restore,
+    handleAndPDSResolver,
+
+}
+

packages/moover/lib/missingBlobs.js

···
+import {AtpAgent} from '@atproto/api';
+import {handleAndPDSResolver} from './atprotoUtils.js';
+
+
+/**
+ * Class to help find missing blobs from the did's previous PDS and import them into the current PDS
+ */
+class MissingBlobs {
+
+    constructor() {
+        /**
+         * The user's current PDS agent
+         * @type {AtpAgent}
+         */
+        this.currentPdsAgent = null;
+        /**
+         * The user's old PDS agent
+         * @type {AtpAgent}
+         */
+        this.oldPdsAgent = null;
+        /**
+         * the user's did
+         * @type {string|null}
+         */
+        this.did = null;
+        /**
+         * The user's current PDS url
+         * @type {null}
+         */
+        this.currentPdsUrl = null;
+        /**
+         * A list of the missing cids blobs from the old PDS. In this case if a retry upload fails it gets put in this array for the ui
+         * @type {string[]}
+         */
+        this.missingBlobs = [];
+
+    }
+
+    /**
+     * Logs the user into the current PDS and gets the account status
+     * @param handle {string}
+     * @param password {string}
+     * @param twoFactorCode {string|null}
+     * @returns {Promise<{accountStatus: OutputSchema, missingBlobsCount: number}>}
+     */
+    async currentAgentLogin(
+        handle,
+        password,
+        twoFactorCode = null,
+    ) {
+        let {usersDid, pds} = await handleAndPDSResolver(handle);
+        this.did = usersDid;
+        this.currentPdsUrl = pds;
+        const agent = new AtpAgent({
+            service: pds,
+        });
+
+        if (twoFactorCode === null) {
+            await agent.login({identifier: usersDid, password});
+        } else {
+            await agent.login({identifier: usersDid, password: password, authFactorToken: twoFactorCode});
+        }
+
+        this.currentPdsAgent = agent;
+
+        const result = await agent.com.atproto.server.checkAccountStatus();
+        const missingBlobs = await this.currentPdsAgent.com.atproto.repo.listMissingBlobs({
+            limit: 10,
+        });
+        return {accountStatus: result.data, missingBlobsCount: missingBlobs.data.blobs.length};
+    }
+
+    /**
+     * Logs into the old PDS and gets the account status.
+     * Does not need a handle
+     * since it is assumed the user has already logged in with the current PDS and we are using their did
+     * @param password {string}
+     * @param twoFactorCode {string|null}
+     * @param pdsUrl {string|null} - If you know the url of the old PDS you can pass it in here. If not it will be guessed at from plc ops
+     * @returns {Promise<void>}
+     */
+    async oldAgentLogin(
+        password,
+        twoFactorCode = null,
+        pdsUrl = null,
+    ) {
+        let oldPds = null;
+
+        if (pdsUrl === null) {
+            const response = await fetch(`https://plc.directory/${this.did}/log`);
+            let auditLog = await response.json();
+            auditLog = auditLog.reverse();
+            let debugCount = 0;
+            for (const entry of auditLog) {
+                console.log(`Loop: ${debugCount++}`);
+                console.log(entry);
+                if (entry.services) {
+                    if (entry.services.atproto_pds) {
+                        if (entry.services.atproto_pds.type === 'AtprotoPersonalDataServer') {
+                            const pds = entry.services.atproto_pds.endpoint;
+                            console.log(`Found PDS: ${pds}`);
+                            if (pds.toLowerCase() !== this.currentPdsUrl.toLowerCase()) {
+                                oldPds = pds;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (oldPds === null) {
+                throw new Error('Could not find your old PDS');
+            }
+        } else {
+            oldPds = pdsUrl;
+        }
+
+        const agent = new AtpAgent({
+            service: oldPds,
+        });
+
+        if (twoFactorCode === null) {
+            await agent.login({identifier: this.did, password});
+        } else {
+            await agent.login({identifier: this.did, password: password, authFactorToken: twoFactorCode});
+        }
+        this.oldPdsAgent = agent;
+    }
+
+    /**
+     * Gets the missing blobs from the old PDS and uploads them to the current PDS
+     * @param statusUpdateHandler {function} - A function to update the status of the migration. This is useful for showing the user the progress of the migration
+     * @returns {Promise<{accountStatus: OutputSchema, missingBlobsCount: number}>}
+     */
+    async migrateMissingBlobs(statusUpdateHandler) {
+        if (this.currentPdsAgent === null) {
+            throw new Error('Current PDS agent is not set');
+        }
+        if (this.oldPdsAgent === null) {
+            throw new Error('Old PDS agent is not set');
+        }
+        statusUpdateHandler('Starting to import blobs...');
+
+        let totalMissingBlobs = 0;
+        let missingBlobCursor = undefined;
+        let missingUploadedBlobs = 0;
+
+        do {
+
+            const missingBlobs = await this.currentPdsAgent.com.atproto.repo.listMissingBlobs({
+                cursor: missingBlobCursor,
+                limit: 1000,
+            });
+            totalMissingBlobs += missingBlobs.data.blobs.length;
+
+            for (const recordBlob of missingBlobs.data.blobs) {
+                try {
+
+                    const blobRes = await this.oldPdsAgent.com.atproto.sync.getBlob({
+                        did: this.did,
+                        cid: recordBlob.cid,
+                    });
+                    let result = await this.currentPdsAgent.com.atproto.repo.uploadBlob(blobRes.data, {
+                        encoding: blobRes.headers['content-type'],
+                    });
+
+                    if (result.status === 429) {
+                        statusUpdateHandler(`You are being rate limited. Will need to try again later to get the rest of the blobs. Migrated blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);
+                    }
+
+                    if (missingUploadedBlobs % 2 === 0) {
+                        statusUpdateHandler(`Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs} (The total may increase as we find more)`);
+                    }
+                    missingUploadedBlobs++;
+                } catch (error) {
+                    console.error(error);
+                    this.missingBlobs.push(recordBlob.cid);
+                }
+            }
+            missingBlobCursor = missingBlobs.data.cursor;
+        } while (missingBlobCursor);
+
+        const accountStatus = await this.currentPdsAgent.com.atproto.server.checkAccountStatus();
+        const missingBlobs = await this.currentPdsAgent.com.atproto.repo.listMissingBlobs({
+            limit: 10,
+        });
+        return {accountStatus: accountStatus.data, missingBlobsCount: missingBlobs.data.blobs.length};
+
+
+    }
+
+}
+
+export {MissingBlobs};

packages/moover/lib/pdsmoover.js

···
+import {docResolver, cleanHandle, handleResolver} from './atprotoUtils.js';
+import {AtpAgent} from '@atproto/api';
+
+
+function safeStatusUpdate(statusUpdateHandler, status) {
+    if (statusUpdateHandler) {
+        statusUpdateHandler(status);
+    }
+}
+
+/**
+ * Handles normal PDS Migrations between two PDSs that are both up.
+ * On pdsmoover.com this is the logic for the MOOver
+ */
+class Migrator {
+    constructor() {
+        /** @type {AtpAgent} */
+        this.oldAgent = null;
+        /** @type {AtpAgent} */
+        this.newAgent = null;
+        /** @type {[string]} */
+        this.missingBlobs = [];
+        //State for reruns
+        /** @type {boolean} */
+        this.createNewAccount = true;
+        /** @type {boolean} */
+        this.migrateRepo = true;
+        /** @type {boolean} */
+        this.migrateBlobs = true;
+        /** @type {boolean} */
+        this.migrateMissingBlobs = true;
+        /** @type {boolean} */
+        this.migratePrefs = true;
+        /** @type {boolean} */
+        this.migratePlcRecord = true;
+    }
+
+    /**
+     * This migrator is pretty cut and dry and makes a few assumptions
+     * 1. You are using the same password between each account
+     * 2. If this command fails for something like oauth 2fa code it throws an error and expects the same values when ran again.
+     * 3. You can control which "actions" happen by setting the class variables to false.
+     * 4. Each instance of the class is assumed to be for a single migration
+     * @param {string} oldHandle - The handle you use on your old pds, something like alice.bsky.social
+     * @param {string} password - Your password for your current login. Has to be your real password, no app password. When setting up a new account we reuse it as well for that account
+     * @param {string} newPdsUrl - The new URL for your pds. Like https://coolnewpds.com
+     * @param {string} newEmail - The email you want to use on the new pds (can be the same as the previous one as long as it's not already being used on the new pds)
+     * @param {string} newHandle - The new handle you want, like alice.bsky.social, or if you already have a domain name set as a handle can use it myname.com.
+     * @param {string|null} inviteCode - The invite code you got from the PDS you are migrating to. If null does not include one
+     * @param {function|null} statusUpdateHandler - a function that takes a string used to update the UI. Like (status) => console.log(status)
+     * @param {string|null} twoFactorCode - Optional, but needed if it fails with 2fa required
+     */
+    async migrate(oldHandle, password, newPdsUrl, newEmail, newHandle, inviteCode, statusUpdateHandler = null, twoFactorCode = null) {
+        //Leaving this logic that either sets the agent to bsky.social, or the PDS since it's what I found worked best for migrations.
+        // handleAndPDSResolver should be able to handle it, but there have been edge cases and this was what worked best
+        oldHandle = cleanHandle(oldHandle);
+        let oldAgent;
+        let usersDid;
+        //If it's a bsky handle just go with the entryway and let it sort everything
+        if (oldHandle.endsWith('.bsky.social')) {
+            oldAgent = new AtpAgent({service: 'https://bsky.social'});
+            const publicAgent = new AtpAgent({service: 'https://public.api.bsky.app'});
+            const resolveIdentityFromEntryway = await publicAgent.com.atproto.identity.resolveHandle({handle: oldHandle});
+            usersDid = resolveIdentityFromEntryway.data.did;
+
+        } else {
+            //Resolves the did and finds the did document for the old PDS
+            safeStatusUpdate(statusUpdateHandler, 'Resolving old PDS');
+            usersDid = await handleResolver.resolve(oldHandle);
+            const didDoc = await docResolver.resolve(usersDid);
+            safeStatusUpdate(statusUpdateHandler, 'Resolving did document and finding your current PDS URL');
+
+            let oldPds;
+            try {
+                oldPds = didDoc.service.filter(s => s.type === 'AtprotoPersonalDataServer')[0].serviceEndpoint;
+            } catch (error) {
+                console.error(error);
+                throw new Error('Could not find a PDS in the DID document.');
+            }
+
+            oldAgent = new AtpAgent({
+                service: oldPds,
+            });
+
+        }
+
+        safeStatusUpdate(statusUpdateHandler, 'Logging you in to the old PDS');
+        //Login to the old PDS
+        if (twoFactorCode === null) {
+            await oldAgent.login({identifier: oldHandle, password});
+        } else {
+            await oldAgent.login({identifier: oldHandle, password: password, authFactorToken: twoFactorCode});
+        }
+
+        safeStatusUpdate(statusUpdateHandler, 'Checking that the new PDS is an actual PDS (if the url is wrong this takes a while to error out)');
+        const newAgent = new AtpAgent({service: newPdsUrl});
+        const newHostDesc = await newAgent.com.atproto.server.describeServer();
+        if (this.createNewAccount) {
+            const newHostWebDid = newHostDesc.data.did;
+
+            safeStatusUpdate(statusUpdateHandler, 'Creating a new account on the new PDS');
+
+            const createAuthResp = await oldAgent.com.atproto.server.getServiceAuth({
+                aud: newHostWebDid,
+                lxm: 'com.atproto.server.createAccount',
+            });
+            const serviceJwt = createAuthResp.data.token;
+
+            let createAccountRequest = {
+                did: usersDid,
+                handle: newHandle,
+                email: newEmail,
+                password: password,
+            };
+            if (inviteCode) {
+                createAccountRequest.inviteCode = inviteCode;
+            }
+            const createNewAccount = await newAgent.com.atproto.server.createAccount(
+                createAccountRequest,
+                {
+                    headers: {authorization: `Bearer ${serviceJwt}`},
+                    encoding: 'application/json',
+                });
+
+            if (createNewAccount.data.did !== usersDid.toString()) {
+                throw new Error('Did not create the new account with the same did as the old account');
+            }
+        }
+        safeStatusUpdate(statusUpdateHandler, 'Logging in with the new account');
+
+        await newAgent.login({
+            identifier: usersDid,
+            password: password,
+        });
+
+        if (this.migrateRepo) {
+            safeStatusUpdate(statusUpdateHandler, 'Migrating your repo');
+            const repoRes = await oldAgent.com.atproto.sync.getRepo({did: usersDid});
+            await newAgent.com.atproto.repo.importRepo(repoRes.data, {
+                encoding: 'application/vnd.ipld.car',
+            });
+        }
+
+        let newAccountStatus = await newAgent.com.atproto.server.checkAccountStatus();
+
+        if (this.migrateBlobs) {
+            safeStatusUpdate(statusUpdateHandler, 'Migrating your blobs');
+
+            let blobCursor = undefined;
+            let uploadedBlobs = 0;
+            do {
+                safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);
+
+                const listedBlobs = await oldAgent.com.atproto.sync.listBlobs({
+                    did: usersDid,
+                    cursor: blobCursor,
+                    limit: 100,
+                });
+
+                for (const cid of listedBlobs.data.cids) {
+                    try {
+                        const blobRes = await oldAgent.com.atproto.sync.getBlob({
+                            did: usersDid,
+                            cid,
+                        });
+                        await newAgent.com.atproto.repo.uploadBlob(blobRes.data, {
+                            encoding: blobRes.headers['content-type'],
+                        });
+                        uploadedBlobs++;
+                        if (uploadedBlobs % 10 === 0) {
+                            safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);
+                        }
+                    } catch (error) {
+                        console.error(error);
+                    }
+                }
+                blobCursor = listedBlobs.data.cursor;
+            } while (blobCursor);
+        }
+
+        if (this.migrateMissingBlobs) {
+            newAccountStatus = await newAgent.com.atproto.server.checkAccountStatus();
+            if (newAccountStatus.data.expectedBlobs !== newAccountStatus.data.importedBlobs) {
+                let totalMissingBlobs = newAccountStatus.data.expectedBlobs - newAccountStatus.data.importedBlobs;
+                safeStatusUpdate(statusUpdateHandler, 'Looks like there are some missing blobs. Going to try and upload them now.');
+                //Probably should be shared between main blob uploader, but eh
+                let missingBlobCursor = undefined;
+                let missingUploadedBlobs = 0;
+                do {
+                    safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);
+
+                    const missingBlobs = await newAgent.com.atproto.repo.listMissingBlobs({
+                        cursor: missingBlobCursor,
+                        limit: 100,
+                    });
+
+                    for (const recordBlob of missingBlobs.data.blobs) {
+                        try {
+
+                            const blobRes = await oldAgent.com.atproto.sync.getBlob({
+                                did: usersDid,
+                                cid: recordBlob.cid,
+                            });
+                            await newAgent.com.atproto.repo.uploadBlob(blobRes.data, {
+                                encoding: blobRes.headers['content-type'],
+                            });
+                            if (missingUploadedBlobs % 10 === 0) {
+                                safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);
+                            }
+                            missingUploadedBlobs++;
+                        } catch (error) {
+                            //TODO silently logging prob should list them so user can manually download
+                            console.error(error);
+                            this.missingBlobs.push(recordBlob.cid);
+                        }
+                    }
+                    missingBlobCursor = missingBlobs.data.cursor;
+                } while (missingBlobCursor);
+
+            }
+        }
+        if (this.migratePrefs) {
+            const prefs = await oldAgent.app.bsky.actor.getPreferences();
+            await newAgent.app.bsky.actor.putPreferences(prefs.data);
+        }
+
+        this.oldAgent = oldAgent;
+        this.newAgent = newAgent;
+
+        if (this.migratePlcRecord) {
+            await oldAgent.com.atproto.identity.requestPlcOperationSignature();
+            safeStatusUpdate(statusUpdateHandler, 'Please check your email for a PLC token');
+        }
+    }
+
+    /**
+     *  Sign and submits the PLC operation to officially migrate the account
+     * @param {string} token - the PLC token sent in the email. If you're just wanting to run this rerun migrate with all the flags set as false except for migratePlcRecord
+     * @param additionalRotationKeysToAdd {string[]} - additional rotation keys to add in addition to the ones provided by the new PDS.
+     * @returns {Promise<void>}
+     */
+    async signPlcOperation(token, additionalRotationKeysToAdd = []) {
+        const getDidCredentials =
+            await this.newAgent.com.atproto.identity.getRecommendedDidCredentials();
+        const pdsProvidedRotationKeys = getDidCredentials.data.rotationKeys ?? [];
+        // Prepend any additional rotation keys (e.g., user-added keys, newly created key) so they appear above the new PDS rotation key
+        const rotationKeys = [...(additionalRotationKeysToAdd || []), ...pdsProvidedRotationKeys];
+        if (!rotationKeys) {
+            throw new Error('No rotation key provided from the new PDS');
+        }
+        const credentials = {
+            ...getDidCredentials.data,
+            rotationKeys: rotationKeys,
+        };
+
+
+        const plcOp = await this.oldAgent.com.atproto.identity.signPlcOperation({
+            token: token,
+            ...credentials,
+        });
+
+        await this.newAgent.com.atproto.identity.submitPlcOperation({
+            operation: plcOp.data.operation,
+        });
+
+        await this.newAgent.com.atproto.server.activateAccount();
+        await this.oldAgent.com.atproto.server.deactivateAccount({});
+    }
+
+    /**
+     * Using this method assumes the Migrator class was constructed new and this was called.
+     * Find the user's previous PDS from the PLC op logs,
+     * logs in and deactivates their old account if it was found still active.
+     *
+     * @param oldHandle {string}
+     * @param oldPassword {string}
+     * @param {function|null} statusUpdateHandler - a function that takes a string used to update the UI.
+     * Like (status) => console.log(status)
+     * @param {string|null} twoFactorCode - Optional, but needed if it fails with 2fa required
+     * @returns {Promise<void>}
+     */
+    async deactivateOldAccount(oldHandle, oldPassword, statusUpdateHandler = null, twoFactorCode = null) {
+        //Leaving this logic that either sets the agent to bsky.social, or the PDS since it's what I found worked best for migrations.
+        // handleAndPDSResolver should be able to handle it, but there have been edge cases and this was what worked best        oldHandle = cleanHandle(oldHandle);
+        let usersDid;
+        //If it's a bsky handle just go with the entryway and let it sort everything
+        if (oldHandle.endsWith('.bsky.social')) {
+            const publicAgent = new AtpAgent({service: 'https://public.api.bsky.app'});
+            const resolveIdentityFromEntryway = await publicAgent.com.atproto.identity.resolveHandle({handle: oldHandle});
+            usersDid = resolveIdentityFromEntryway.data.did;
+        } else {
+            //Resolves the did and finds the did document for the old PDS
+            safeStatusUpdate(statusUpdateHandler, 'Resolving did from handle');
+            usersDid = await handleResolver.resolve(oldHandle);
+        }
+
+        const didDoc = await docResolver.resolve(usersDid);
+        let currentPds;
+        try {
+            currentPds = didDoc.service.filter(s => s.type === 'AtprotoPersonalDataServer')[0].serviceEndpoint;
+        } catch (error) {
+            console.error(error);
+            throw new Error('Could not find a PDS in the DID document.');
+        }
+
+        const plcLogRequest = await fetch(`https://plc.directory/${usersDid}/log`);
+        const plcLog = await plcLogRequest.json();
+        let pdsBeforeCurrent = '';
+        for (const log of plcLog) {
+            try {
+                const pds = log.services.atproto_pds.endpoint;
+                if (pds.toLowerCase() === currentPds.toLowerCase()) {
+                    console.log('Found the PDS before the current one');
+                    break;
+                }
+                pdsBeforeCurrent = pds;
+            } catch (e) {
+                console.log(e);
+            }
+        }
+        if (pdsBeforeCurrent === '') {
+            throw new Error('Could not find the PDS before the current one');
+        }
+
+        let oldAgent = new AtpAgent({service: pdsBeforeCurrent});
+        safeStatusUpdate(statusUpdateHandler, `Logging you in to the old PDS: ${pdsBeforeCurrent}`);
+        //Login to the old PDS
+        if (twoFactorCode === null) {
+            await oldAgent.login({identifier: oldHandle, password: oldPassword});
+        } else {
+            await oldAgent.login({identifier: oldHandle, password: oldPassword, authFactorToken: twoFactorCode});
+        }
+        safeStatusUpdate(statusUpdateHandler, 'Checking this isn\'t your current PDS');
+        if (pdsBeforeCurrent === currentPds) {
+            throw new Error('This is your current PDS. Login to your old account username and password');
+        }
+
+        let currentAccountStatus = await oldAgent.com.atproto.server.checkAccountStatus();
+        if (!currentAccountStatus.data.activated) {
+            safeStatusUpdate(statusUpdateHandler, 'All good. Your old account is not activated.');
+        }
+        safeStatusUpdate(statusUpdateHandler, 'Deactivating your OLD account');
+        await oldAgent.com.atproto.server.deactivateAccount({});
+        safeStatusUpdate(statusUpdateHandler, 'Successfully deactivated your OLD account');
+    }
+
+    /**
+     * Signs the logged-in user in this.newAgent for backups with PDS MOOver. This is usually called after migrate and signPlcOperation are successful
+     *
+     * @param {string} didWeb
+     * @returns {Promise<void>}
+     */
+    async signUpForBackupsFromMigration(didWeb = 'did:web:pdsmoover.com') {
+
+        //Manually grabbing the jwt and making a call with fetch cause for the life of me I could not figure out
+        //how you used @atproto/api to make a call for proxying
+        const url = `${this.newAgent.serviceUrl.origin}/xrpc/com.pdsmoover.backup.signUp`;
+
+        const accessJwt = this.newAgent?.session?.accessJwt;
+        if (!accessJwt) {
+            throw new Error('Missing access token for authorization');
+        }
+
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessJwt}`,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'atproto-proxy': `${didWeb}#repo_backup`,
+            },
+            body: JSON.stringify({}),
+        });
+
+        if (!res.ok) {
+            let bodyText = '';
+            try {
+                bodyText = await res.text();
+            } catch {
+            }
+            throw new Error(`Backup signup failed: ${res.status} ${res.statusText}${bodyText ? ` - ${bodyText}` : ''}`);
+        }
+
+        //No return the success is all that is needed, if there's an error it will throw
+    }
+}
+
+export {Migrator};
+

packages/moover/lib/plc-ops.js

···
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ * @typedef {import('@atcute/did-plc').defs} defs
+ * @typedef {import('@atcute/did-plc').normalizeOp} normalizeOp
+ * @typedef {import('@atcute/did-plc').Operation} Operation
+ * @typedef {import('@atcute/did-plc').CompatibleOperation} CompatibleOperation
+ * @typedef {import('@atcute/did-plc').IndexedEntryLog} IndexedEntryLog
+ * @typedef {import('@atcute/did-plc').IndexedEntry} IndexedEntry
+ */
+
+import {defs, normalizeOp} from '@atcute/did-plc';
+import {P256PrivateKey, parsePrivateMultikey, Secp256k1PrivateKey, Secp256k1PrivateKeyExportable} from '@atcute/crypto';
+import * as CBOR from '@atcute/cbor';
+import {fromBase16, toBase64Url} from '@atcute/multibase';
+
+
+// Helper to base64url-encode JSON
+const jsonToB64Url = (obj) => {
+    const enc = new TextEncoder();
+    const json = JSON.stringify(obj);
+    return toBase64Url(enc.encode(json));
+};
+
+/**
+ * Class to help with various PLC operations
+ */
+class PlcOps {
+    /**
+     *
+     * @param plcDirectoryUrl {string} - The url of the plc directory, defaults to https://plc.directory
+     */
+    constructor(plcDirectoryUrl = 'https://plc.directory') {
+        /**
+         * The url of the plc directory
+         * @type {string}
+         */
+        this.plcDirectoryUrl = plcDirectoryUrl;
+    }
+
+    /**
+     *  Gets the current rotation keys for a user via their last PlC operation
+     * @param did
+     * @returns {Promise<string[]>}
+     */
+    async getCurrentRotationKeysForUser(did) {
+        const logs = await this.getPlcAuditLogs(did);
+        const {lastOperation} = this.getLastPlcOp(logs);
+        return lastOperation.rotationKeys || [];
+    }
+
+    /**
+     *  Gets the last PlC operation for a user from the plc directory
+     * @param did
+     * @returns {Promise<{lastOperation: Operation, base: any}>}
+     */
+    async getLastPlcOpFromPlc(did) {
+        const logs = await this.getPlcAuditLogs(did);
+        return this.getLastPlcOp(logs);
+    }
+
+    /**
+     *
+     * @param logs {IndexedEntryLog}
+     * @returns {{lastOperation: Operation, base: IndexedEntry}}
+     */
+    getLastPlcOp(logs) {
+        const lastOp = logs.at(-1);
+        return {lastOperation: normalizeOp(lastOp.operation), base: lastOp};
+    }
+
+
+    /**
+     *  Gets the plc audit logs for a user from the plc directory
+     * @param did
+     * @returns {Promise<IndexedEntryLog>}
+     */
+    async getPlcAuditLogs(did) {
+        const response = await fetch(`${this.plcDirectoryUrl}/${did}/log/audit`);
+        if (!response.ok) {
+            throw new Error(`got response ${response.status}`);
+        }
+
+        const json = await response.json();
+        return defs.indexedEntryLog.parse(json);
+    }
+
+    /**
+     * Creates a new secp256k1 key that can be used for either rotation or verification key
+     * @returns {Promise<{privateKey: string, publicKey: `did:key:${string}`}>}
+     */
+    async createANewSecp256k1() {
+        let keypair = await Secp256k1PrivateKeyExportable.createKeypair();
+        let publicKey = await keypair.exportPublicKey('did');
+        let privateKey = await keypair.exportPrivateKey('multikey');
+        return {
+            privateKey,
+            publicKey
+        };
+    }
+
+
+    /**
+     * Signs a new operation with the provided signing key, and information and submits it to the plc directory
+     * @param did {string} - The user's did
+     * @param signingRotationKey { P256PrivateKey|Secp256k1PrivateKey} - The keypair to sign the op with
+     * @param alsoKnownAs {string[]}
+     * @param rotationKeys {string[]}
+     * @param pds {string}
+     * @param verificationKey {string} - The public verification key
+     * @param prev {string} - The previous valid operation's cid.
+     * @returns {Promise<void>}
+     */
+    async signAndPublishNewOp(did, signingRotationKey, alsoKnownAs, rotationKeys, pds, verificationKey, prev) {
+        
+        const rotationKeysToUse = [...new Set(rotationKeys)];
+        if (!rotationKeysToUse) {
+            throw new Error('No rotation keys were found to be added to the PLC');
+        }
+
+        if (rotationKeysToUse.length > 5) {
+            throw new Error('You can only add up to 5 rotation keys to the PLC');
+        }
+
+        const operation = {
+            type: 'plc_operation',
+            prev,
+            alsoKnownAs,
+            rotationKeys: rotationKeysToUse,
+            services: {
+                atproto_pds: {
+                    type: 'AtprotoPersonalDataServer',
+                    endpoint: pds
+                }
+            },
+            verificationMethods: {
+                atproto: verificationKey
+            }
+        };
+        const opBytes = CBOR.encode(operation);
+        const sigBytes = await signingRotationKey.sign(opBytes);
+
+        const signature = toBase64Url(sigBytes);
+
+        const signedOperation = {
+            ...operation,
+            sig: signature,
+        };
+
+        await this.pushPlcOperation(did, signedOperation);
+    }
+
+    /**
+     * Takes a multi or hex based private key and returns a keypair
+     * @param privateKeyString {string}
+     * @param type {string} - secp256k1 or p256, needed if the private key is hex based, can be assumed if it's a multikey
+     * @returns {Promise<{type: string, didPublicKey: `did:key:${string}`, keypair: P256PrivateKey|Secp256k1PrivateKey}>}
+     */
+    async getKeyPair(privateKeyString, type = 'secp256k1') {
+        const HEX_REGEX = /^[0-9a-f]+$/i;
+        const MULTIKEY_REGEX = /^z[a-km-zA-HJ-NP-Z1-9]+$/;
+        let keypair = undefined;
+
+        if (HEX_REGEX.test(privateKeyString)) {
+            const privateKeyBytes = fromBase16(privateKeyString);
+
+            switch (type) {
+                case 'p256': {
+                    keypair = await P256PrivateKey.importRaw(privateKeyBytes);
+                    break;
+                }
+                case 'secp256k1': {
+                    keypair = await Secp256k1PrivateKey.importRaw(privateKeyBytes);
+                    break;
+                }
+                default: {
+                    throw new Error(`unsupported "${type}" type`);
+                }
+            }
+        } else if (MULTIKEY_REGEX.test(privateKeyString)) {
+
+            const match = parsePrivateMultikey(privateKeyString);
+            const privateKeyBytes = match.privateKeyBytes;
+
+            switch (match.type) {
+                case 'p256': {
+                    keypair = await P256PrivateKey.importRaw(privateKeyBytes);
+                    console.log(keypair);
+                    break;
+                }
+                case 'secp256k1': {
+                    keypair = await Secp256k1PrivateKey.importRaw(privateKeyBytes);
+                    break;
+                }
+                default: {
+                    throw new Error(`unsupported "${type}" type`);
+                }
+            }
+        } else {
+            throw new Error('unknown input format');
+        }
+        return {
+            type: 'private_key',
+            didPublicKey: await keypair.exportPublicKey('did'),
+            keypair: keypair,
+        };
+    }
+
+    /**
+     * Submits a new operation to the plc directory
+     * @param did {string} - The user's did
+     * @param operation
+     * @returns {Promise<void>}
+     */
+    async pushPlcOperation(did, operation) {
+        const response = await fetch(`${this.plcDirectoryUrl}/${did}`, {
+            method: 'post',
+            headers: {
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(operation),
+        });
+
+        const headers = response.headers;
+        if (!response.ok) {
+            const type = headers.get('content-type');
+
+            if (type?.includes('application/json')) {
+                const json = await response.json();
+                if (typeof json === 'object' && json !== null && typeof json.message === 'string') {
+                    throw new Error(json.message);
+                }
+            }
+
+            throw new Error(`got http ${response.status} from plc`);
+        }
+    };
+
+
+    /**
+     * Creates a new service auth token for a user. This is what is used to create a new account on a PDS for your did
+     *
+     * @param iss The user's did
+     * @param aud The did:web, if it's a PDS it's usually from /xrpc/com.atproto.server.describeServer
+     * @param keypair The keypair to sign with only supporting ES256K atm
+     * @param lxm The lxm which is usually com.atproto.server.createAccount for creating a new account
+     * @returns {Promise<string>}
+     */
+    async createANewServiceAuthToken(iss, aud, keypair, lxm) {
+
+
+        // Compute iat/exp defaults (60s window like reference: MINUTE/1e3)
+        const iat = Math.floor(Date.now() / 1e3);
+        const exp = iat + 60;
+
+        // Generate a 16-byte hex jti
+        const jti = (() => {
+            const bytes = new Uint8Array(16);
+            // crypto in browser or node; fall back safely
+            (globalThis.crypto || window.crypto).getRandomValues(bytes);
+            return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+        })();
+
+
+        // Build header and payload (omit undefined fields)
+        // Just defaulting to ES256K since p256 was not importing on firefox
+        const header = {typ: 'JWT', alg: 'ES256K'};
+        const payload = {};
+        payload.iat = iat;
+        payload.iss = iss;
+        payload.aud = aud;
+        payload.exp = exp;
+        payload.lxm = lxm;
+        payload.jti = jti;
+
+        const headerB64 = jsonToB64Url(header);
+        const payloadB64 = jsonToB64Url(payload);
+        const toSignStr = `${headerB64}.${payloadB64}`;
+
+        // Sign
+        const toSignBytes = new TextEncoder().encode(toSignStr);
+        const sigBytes = await keypair.sign(toSignBytes);
+
+        // Return compact JWS
+        const sigB64 = toBase64Url(sigBytes);
+        return `${toSignStr}.${sigB64}`;
+    }
+
+
+}
+
+
+export {PlcOps};

packages/moover/lib/restore.js

···
+/**
+ * @typedef {import('@atcute/did-plc').Operation} Operation
+ */
+import {P256PrivateKey, Secp256k1PrivateKey} from '@atcute/crypto';
+import {handleAndPDSResolver} from './atprotoUtils.js';
+import {PlcOps} from './plc-ops.js';
+import {normalizeOp} from '@atcute/did-plc';
+import {AtpAgent} from '@atproto/api';
+import {Secp256k1PrivateKeyExportable} from '@atcute/crypto';
+import * as CBOR from '@atcute/cbor';
+import {toBase64Url} from '@atcute/multibase';
+
+class Restore {
+
+    /**
+     *
+     * @param pdsMooverInstance {string} - The url of the pds moover instance to restore from. Defaults to https://pdsmover.com
+     */
+    constructor(pdsMooverInstance = 'https://pdsmover.com') {
+        /**
+         * If you want to use a different plc directory create your own instance of the plc ops class and pass it in here
+         * @type {PlcOps} */
+        this.plcOps = new PlcOps();
+
+        /**
+         * This is the base url for the pds moover instance used to restore the files from a backup.
+         * @type {string}
+         */
+        this.pdsMooverInstance = pdsMooverInstance
+
+        /**
+         * To keep it simple, only uses secp256k for the temp verification key that is used to create the new account on the new PDS
+         * and is temporarily assigned to the user's account on PLC
+         * @type {null|Secp256k1PrivateKeyExportable}
+         */
+        this.tempVerificationKeypair = null;
+
+        /** @type {AtpAgent} */
+        this.atpAgent = null;
+
+        /**
+         * The keypair that is used to sign the plc operation
+         * @type {null|{type: string, didPublicKey: `did:key:${string}`, keypair: P256PrivateKey|Secp256k1PrivateKey}}
+         */
+        this.recoveryRotationKeyPair = null;
+
+        /**
+         * If this is true we are just restoring the repo and blobs. Ideally for rerunning a restore process after account recovery
+         * @type {boolean}
+         */
+        this.RestoreFromBackup = true;
+
+        /**
+         * If set to true then it will do the account recovery. Writes a temp key to the did doc,
+         * create a new account on the new pds, and then submit a new plc op for the pds to have control (finishes the migration, can always restore the backup later)
+         * @type {boolean}
+         */
+        this.AccountRecovery = true;
+    }
+
+    /**
+     *  Recovers an account with the users rotation key and restores the repo from a PDS MOOver backup
+     *  This method can fail, and the account was still recovered, it's best to check the PLC logs to see where an account stands before reruns
+     * @param rotationKey {string} - The users private rotation key, can be a multi key or hex key
+     * @param rotationKeyType {string} - The type of the key, secp256k1 or p256. Required if the key is in hex format, defaults to secp256k1
+     * @param currentHandleOrDid {string} - The users current handle or did, if they don't have a DNS record it will have to be their did for success
+     * @param newPDS {string} - The new PDS url, like https://coolnewpds.com
+     * @param newHandle {string} - Can be the users DNS handle if it is already setup with their did, if not it's bob.mypds.com
+     * @param newPassword {string} - The new password for the new account
+     * @param newEmail {string} - The new email for the new account
+     * @param inviteCode {string|null} - The invite code for the new PDS if it requires one
+     * @param cidToRestoreTo {string|null} - The cid of the plc op to restore to, used mostly to revert a fraudulent plc op. Want to give it the last valid operations cid
+     * @param onStatus {function|null} - A function that takes a string used to update the UI. Like (status) => console.log(status)
+     * @returns {Promise<void>} If there is a failure during restoring the back up (after the status Success! Restoring your repo...) then your account is most likely
+     * recovered and future runs need to have the RestoreFromBackup flag set to true and AccountRecovery set to false.
+     */
+    async recover(
+        rotationKey,
+        rotationKeyType = 'secp256k1',
+        currentHandleOrDid,
+        newPDS,
+        newHandle,
+        newPassword,
+        newEmail,
+        inviteCode,
+        cidToRestoreTo = null,
+        onStatus = null) {
+
+        if (onStatus) onStatus('Resolving your handle...');
+
+        let {usersDid} = await handleAndPDSResolver(currentHandleOrDid);
+
+        if (onStatus) onStatus('Checking that the new PDS is an actual PDS (if the url is wrong, this takes a while to error out)');
+        this.atpAgent = new AtpAgent({service: newPDS});
+        const newHostDesc = await this.atpAgent.com.atproto.server.describeServer();
+
+
+        //Check to see if the user already has a repo on the new PDS, if they do no reason to try and restore via the plc operations
+        try {
+            await this.atpAgent.com.atproto.repo.describeRepo({repo: usersDid.toString()});
+            //If we got this far and there is a repo on the new PDS with the users did, we can just move on and restore the files.
+            //We do not want to mess with the plc ops if we dont have to
+            this.AccountRecovery = false;
+
+        } catch (error) {
+            console.error(error);
+            let parsedError = error.error;
+            if (parsedError === 'RepoDeactivated') {
+                //Ideally should mean they already have a repo on the new PDS and we just need to restore the files
+                this.AccountRecovery = false;
+            }
+            //This is the error we want to see, anything else throw
+            if (parsedError !== 'RepoNotFound') {
+                throw error;
+            }
+        }
+
+        //We need to double check that the new handle has not been taken, if it has we need to throw an error
+        //We care a bit more because we do not want any unnecessary plc ops to be created
+        try {
+            let resolveHandle = await this.atpAgent.com.atproto.identity.resolveHandle({handle: newHandle});
+            if (resolveHandle.data.did === usersDid.toString()) {
+                //This was originally setting the AccountRecovery to false, which works if it is resolved via .well-known, but not dns
+                //The idea was to check and see if the handle has been taken. just leaving for now since it does that check and if the user owns the handle
+                //their did should be set anyhow
+
+            } else {
+                //There is a repo with that name and it's not the users did,
+                throw new Error('The new handle is already taken, please select a different handle');
+            }
+        } catch (error) {
+            // Going to silently log this and just assume the handle has not been taken.
+            console.error(error);
+            if (error.message.startsWith('The new handle')) {
+                //it's not our custom error, so we can just throw it
+                throw error;
+            }
+
+        }
+
+        if (this.AccountRecovery) {
+
+            if (onStatus) onStatus('Validating your private rotation key is in the correct format...');
+
+            this.recoveryRotationKeyPair = await this.plcOps.getKeyPair(rotationKey, rotationKeyType);
+
+
+            if (onStatus) onStatus('Resolving PlC operation logs...');
+
+            /** @type  {Operation} */
+            let baseOpForSigning = null;
+            let opPrevCid = null;
+
+            //This is for reversals against a rogue plc op and you want to restore to a specific cid in the audit log
+            if (cidToRestoreTo) {
+                let auditLogs = await this.plcOps.getPlcAuditLogs(usersDid);
+                for (const log of auditLogs) {
+                    if (log.cid === cidToRestoreTo) {
+                        baseOpForSigning = normalizeOp(log.operation);
+                        opPrevCid = log.cid;
+                        break;
+                    }
+                }
+                if (!baseOpForSigning) {
+                    throw new Error('Could not find the cid in the audit logs');
+                }
+            } else {
+                let {lastOperation, base} = await this.plcOps.getLastPlcOpFromPlc(usersDid);
+                opPrevCid = base.cid;
+                baseOpForSigning = lastOperation;
+            }
+
+            if (onStatus) onStatus('Preparing to switch to a temp atproto key...');
+            if (this.tempVerificationKeypair == null) {
+                if (onStatus) onStatus('Creating a new temp atproto key...');
+                this.tempVerificationKeypair = await Secp256k1PrivateKeyExportable.createKeypair();
+            }
+            //Just defaulting to the user's recovery key for now. Advance cases will be something else
+            //Maybe just a new ui to edit the PLC doc in a limited capacity, but sinc ethis is a temp plc op i don't think it's needed
+            let tempRotationKeys = [this.recoveryRotationKeyPair.didPublicKey];
+
+            if (onStatus) onStatus('Modifying the PLC OP for recovery...');
+            //A temp plc op for control of the atproto key to create a serviceAuth and new account on the new PDS
+            await this.plcOps.signAndPublishNewOp(
+                usersDid,
+                this.recoveryRotationKeyPair.keypair,
+                baseOpForSigning.alsoKnownAs,
+                tempRotationKeys,
+                newPDS,
+                await this.tempVerificationKeypair.exportPublicKey('did'),
+                opPrevCid);
+
+
+            if (onStatus) onStatus('Creating your new account on the new PDS...');
+            let serviceAuthToken = await this.plcOps.createANewServiceAuthToken(usersDid, newHostDesc.data.did, this.tempVerificationKeypair, 'com.atproto.server.createAccount');
+
+            let createAccountRequest = {
+                did: usersDid,
+                handle: newHandle,
+                email: newEmail,
+                password: newPassword,
+            };
+            if (inviteCode) {
+                createAccountRequest.inviteCode = inviteCode;
+            }
+            const _ = await this.atpAgent.com.atproto.server.createAccount(
+                createAccountRequest,
+                {
+                    headers: {authorization: `Bearer ${serviceAuthToken}`},
+                    encoding: 'application/json',
+                });
+        }
+
+        await this.atpAgent.login({
+            identifier: usersDid,
+            password: newPassword,
+        });
+
+        if (this.AccountRecovery) {
+            //Moving the user offically to the new PDS
+            if (onStatus) onStatus('Signing the papers...');
+            let {base} = await this.plcOps.getLastPlcOpFromPlc(usersDid);
+            await this.signRestorePlcOperation(usersDid, [this.recoveryRotationKeyPair.didPublicKey], base.cid);
+        }
+
+        if (this.RestoreFromBackup) {
+            if (onStatus) onStatus('Success! Restoring your repo...');
+            const pdsMoover = new AtpAgent({service: this.pdsMooverInstance});
+            const repoRes = await pdsMoover.com.atproto.sync.getRepo({did: usersDid});
+            await this.atpAgent.com.atproto.repo.importRepo(repoRes.data, {
+                encoding: 'application/vnd.ipld.car',
+            });
+
+            if (onStatus) onStatus('Restoring your blobs...');
+
+            //Using the missing endpoint to findout what's missing then the PDS MOOver endpoint to restore
+            let totalMissingBlobs = 0;
+            let missingBlobCursor = undefined;
+            let missingUploadedBlobs = 0;
+
+            do {
+
+                const missingBlobs = await this.atpAgent.com.atproto.repo.listMissingBlobs({
+                    cursor: missingBlobCursor,
+                    limit: 1000,
+                });
+                totalMissingBlobs += missingBlobs.data.blobs.length;
+
+                for (const recordBlob of missingBlobs.data.blobs) {
+                    try {
+
+                        const blobRes = await pdsMoover.com.atproto.sync.getBlob({
+                            did: usersDid,
+                            cid: recordBlob.cid,
+                        });
+                        let result = await this.atpAgent.com.atproto.repo.uploadBlob(blobRes.data, {
+                            encoding: blobRes.headers['content-type'],
+                        });
+
+
+                        if (missingUploadedBlobs % 2 === 0) {
+                            if (onStatus) onStatus(`Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs} (The total may increase as we find more)`);
+                        }
+                        missingUploadedBlobs++;
+                    } catch (error) {
+                        console.error(error);
+                    }
+                }
+                missingBlobCursor = missingBlobs.data.cursor;
+            } while (missingBlobCursor);
+        }
+        const accountStatus = await this.atpAgent.com.atproto.server.checkAccountStatus();
+        if (!accountStatus.data.activated) {
+            if (onStatus) onStatus('Activating your account...');
+            await this.atpAgent.com.atproto.server.activateAccount();
+        }
+
+    }
+
+
+    /**
+     * This method signs the plc operation over to the new PDS and activates the account
+     * Assumes you have already created a new account during the recovery process and logged in
+     * Uses the recommended did doc from the PDS as a base and adds the users rotation key to the rotation keys array
+     *
+     * @param usersDid
+     * @param additionalRotationKeysToAdd
+     * @param prevCid
+     * @returns {Promise<void>}
+     */
+    async signRestorePlcOperation(usersDid, additionalRotationKeysToAdd = [], prevCid) {
+        const getDidCredentials =
+            await this.atpAgent.com.atproto.identity.getRecommendedDidCredentials();
+
+        const pdsProvidedRotationKeys = getDidCredentials.data.rotationKeys ?? [];
+        //Puts the provided rotation keys above the pds pro
+        const rotationKeys = [...new Set([...(additionalRotationKeysToAdd || []), ...pdsProvidedRotationKeys])];
+        if (!rotationKeys) {
+            throw new Error('No rotation keys were found to be added to the PLC');
+        }
+
+        if (rotationKeys.length > 5) {
+            throw new Error('You can only add up to 5 rotation keys to the PLC');
+        }
+
+
+        const plcOpToSubmit = {
+            type: 'plc_operation',
+            ...getDidCredentials.data,
+            prev: prevCid,
+            rotationKeys: rotationKeys,
+        };
+
+
+        const opBytes = CBOR.encode(plcOpToSubmit);
+        const sigBytes = await this.recoveryRotationKeyPair.keypair.sign(opBytes);
+
+        const signature = toBase64Url(sigBytes);
+
+        const signedOperation = {
+            ...plcOpToSubmit,
+            sig: signature,
+        };
+
+        await this.plcOps.pushPlcOperation(usersDid, signedOperation);
+        await this.atpAgent.com.atproto.server.activateAccount();
+
+    }
+}
+
+export {Restore};

packages/moover/package.json

···
+{
+  "name": "@pds-moover/moover",
+  "version": "1.0.4",
+  "description": "Utilities for ATProto PDS migrations and recovery",
+  "repository": {
+    "type": "git",
+    "url": "https://tangled.org/@baileytownsend.dev/pds-moover",
+    "directory": "packages/moover"
+  },
+  "keywords": [
+    "atproto",
+    "pds",
+    "migration",
+    "recovery",
+    "PDS MOOver"
+  ],
+  "author": "Bailey Townsend",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "main": "./dist/pds-moover.umd.cjs",
+  "module": "./dist/pds-moover.js",
+  "types": "./types/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/main.d.ts",
+      "import": "./dist/pds-moover.js",
+      "require": "./dist/pds-moover.umd.cjs"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "gen:types": "tsc -p .",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "eslint": "^9.34.0",
+    "eslint-plugin-import": "^2.32.0",
+    "vite": "^7.1.7"
+  },
+  "dependencies": {
+    "@atcute/cbor": "^2.2.7",
+    "@atcute/client": "^4.0.4",
+    "@atcute/crypto": "^2.2.5",
+    "@atcute/did-plc": "^0.1.7",
+    "@atcute/identity-resolver": "^1.1.3",
+    "@atcute/lexicons": "^1.2.2",
+    "@atcute/multibase": "^1.1.6",
+    "@atproto/api": "^0.16.7",
+    "@pds-moover/lexicons": "^1.0.0",
+    "alpinejs": "^3.15.0",
+    "vite-plugin-full-reload": "^1.2.0",
+    "vite-rs-plugin": "1.0.1"
+  }
+}

packages/moover/tsconfig.json

···
+{
+  "include": [
+    "lib/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "types"
+  ],
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": false,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": true,
+    "outDir": "types",
+    // or use "declarationDir": "types"
+
+    "target": "ES2022",
+    "lib": [
+      "ES2022"
+    ],
+    // add "DOM" if you use browser APIs
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    // or "NodeNext" depending on your setup
+    "rootDir": "lib"
+  }
+}

packages/moover/types/atprotoUtils.d.ts

···
+export const handleResolver: CompositeHandleResolver;
+export const docResolver: CompositeDidDocumentResolver<"plc" | "web">;
+/**
+ * Cleans the handle of @ and some other unicode characters that used to show up when copied from the profile
+ * @param handle {string}
+ * @returns {string}
+ */
+export function cleanHandle(handle: string): string;
+/**
+ *  Convince helper to resolve a handle to a did and then find the PDS url from the did document.
+ *
+ * @param handle
+ * @returns {Promise<{usersDid: string, pds: string}>}
+ */
+export function handleAndPDSResolver(handle: any): Promise<{
+    usersDid: string;
+    pds: string;
+}>;
+/**
+ *  Fetches the DID Web from the .well-known/did.json endpoint of the server.
+ *  Legacy and was helpful if the web ui and server are on the same domain, not as useful now
+ * @param baseUrl
+ * @returns {Promise<*>}
+ */
+export function fetchPDSMooverDIDWeb(baseUrl: any): Promise<any>;
+import { CompositeHandleResolver } from '@atcute/identity-resolver';
+import { CompositeDidDocumentResolver } from '@atcute/identity-resolver';
+//# sourceMappingURL=atprotoUtils.d.ts.map

packages/moover/types/atprotoUtils.d.ts.map

···
+{"version":3,"file":"atprotoUtils.d.ts","sourceRoot":"","sources":["../lib/atprotoUtils.js"],"names":[],"mappings":"AAOA,qDAQG;AAEH,sEAKG;AAEH;;;;GAIG;AACH,oCAHkB,MAAM,GACX,MAAM,CAMd;AAGL;;;;;GAKG;AACH,mDAFa,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,CAAC,CAqBpD;AAGD;;;;;GAKG;AACH,oDAFa,OAAO,CAAC,GAAC,CAAC,CAStB;wCAxEM,2BAA2B;6CAA3B,2BAA2B"}

packages/moover/types/backup.d.ts

···
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ */
+export type InferXRPCBodyOutput = any;
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ * @typedef {import('@atcute/lexicons').InferXRPCBodyOutput} InferXRPCBodyOutput
+ */
+/**
+ * Logic to sign up and manage backups for pdsmoover.com (or your own selfhosted instance)
+ */
+export class BackupService {
+    /**
+     *
+     * @param backupDidWeb {string} - The did:web for the xrpc service for backups, defaults to did:web:pdsmoover.com
+     */
+    constructor(backupDidWeb?: string);
+    /**
+     *
+     * @type {Client}
+     */
+    atCuteClient: Client;
+    /**
+     *
+     * @type {CredentialManager}
+     */
+    atCuteCredentialManager: CredentialManager;
+    /**
+     * The did:web for the xrpc service for backups, defaults to pdsmoover.com
+     * @type {string}
+     */
+    backupDidWeb: string;
+    /**
+     *  Logs in and returns the backup status.
+     *  To use the rest of the BackupService, it is assumed that this has ran first,
+     *  and the user has successfully signed up. A successful login is a returned null if the user has not signed up.
+     *  or the backup status if they are
+     *
+     *  If the server requires 2FA,
+     *  it will throw with error.error === 'AuthFactorTokenRequired'.
+     * @param identifier {string} handle or did
+     * @param password {string}
+     * @param {function|null} onStatus - a function that takes a string used to update the UI.
+     * Like (status) => console.log(status)
+     * @param twoFactorCode {string|null}
+     *
+     * @returns {Promise<InferXRPCBodyOutput<ComPdsmooverBackupDescribeServer.mainSchema['output']>|null>}
+     */
+    loginAndStatus(identifier: string, password: string, onStatus?: Function | null, twoFactorCode?: string | null): Promise<InferXRPCBodyOutput<ComPdsmooverBackupDescribeServer.mainSchema["output"]> | null>;
+    /**
+     * Signs the user up for backups with the service
+     * @param onStatus
+     * @returns {Promise<void>}
+     */
+    signUp(onStatus?: any): Promise<void>;
+    /**
+     * Requests a PLC token to be sent to the user's email, needed to add a new rotation key
+     * @returns {Promise<void>}
+     */
+    requestAPlcToken(): Promise<void>;
+    /**
+     *  Adds a new rotation to the users did document. Assumes you are already signed in.
+     *
+     *  WARNING: This will overwrite any existing rotation keys with the new one at the top, and the PDS key as the second one
+     * @param plcToken {string} - PLC token from the user's email that was sent from requestAPlcToken
+     * @param rotationKey {string} - The new rotation key to add to the user's did document
+     * @returns {Promise<void>}
+     */
+    addANewRotationKey(plcToken: string, rotationKey: string): Promise<void>;
+    /**
+     *
+     *  Gets the current status of the user's backup repository.
+     *
+     * @param onStatus {function|null} - a function that takes a string used to update the UI.
+     * @returns {Promise<InferXRPCBodyOutput<ComPdsmooverBackupDescribeServer.mainSchema['output']>>}
+     */
+    getUsersRepoStatus(onStatus?: Function | null): Promise<InferXRPCBodyOutput<ComPdsmooverBackupDescribeServer.mainSchema["output"]>>;
+    /**
+     * Requests a backup to be run immediately for the signed-in user. Usually does, depend on the server's backup queue
+     * @param onStatus
+     * @returns {Promise<boolean>}
+     */
+    runBackupNow(onStatus?: any): Promise<boolean>;
+    /**
+     * Remove (delete) the signed-in user's backup repository. this also deletes all the user's backup data.
+     * @param onStatus
+     * @returns {Promise<boolean>}
+     */
+    removeRepo(onStatus?: any): Promise<boolean>;
+}
+import { Client } from '@atcute/client';
+import { CredentialManager } from '@atcute/client';
+import { ComPdsmooverBackupDescribeServer } from '@pds-moover/lexicons';
+//# sourceMappingURL=backup.d.ts.map

packages/moover/types/backup.d.ts.map

···
+{"version":3,"file":"backup.d.ts","sourceRoot":"","sources":["../lib/backup.js"],"names":[],"mappings":";;;;AAKA;;;GAGG;AAGH;;GAEG;AACH;IACI;;;OAGG;IACH,2BAFwB,MAAM,EAmB7B;IAhBG;;;OAGG;IACH,cAFU,MAAM,CAEQ;IACxB;;;OAGG;IACH,yBAFU,iBAAiB,CAEQ;IAEnC;;;OAGG;IACH,cAFU,MAAM,CAEgB;IAIpC;;;;;;;;;;;;;;;OAeG;IACH,2BARsB,MAAM,YACR,MAAM,aACf,WAAS,IAAI,kBAEC,MAAM,GAAC,IAAI,GAEvB,OAAO,CAAC,mBAAmB,CAAC,gCAAgC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,GAAC,IAAI,CAAC,CAyDpG;IAED;;;;OAIG;IACH,wBAFa,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;OAGG;IACH,oBAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;;;OAOG;IACH,6BAJoB,MAAM,eACH,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAgDzB;IAGD;;;;;;OAMG;IACH,8BAHoB,WAAS,IAAI,GACpB,OAAO,CAAC,mBAAmB,CAAC,gCAAgC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAe/F;IAED;;;;OAIG;IACH,8BAFa,OAAO,CAAC,OAAO,CAAC,CAkB5B;IAED;;;;OAIG;IACH,4BAFa,OAAO,CAAC,OAAO,CAAC,CAe5B;CACJ;uBAhR2C,gBAAgB;kCAAhB,gBAAgB;iDAGb,sBAAsB"}

packages/moover/types/main.d.ts

···
+import { Migrator } from './pdsmoover.js';
+import { MissingBlobs } from './missingBlobs.js';
+import { BackupService } from './backup.js';
+import { PlcOps } from './plc-ops.js';
+import { Restore } from './restore.js';
+import { handleAndPDSResolver } from './atprotoUtils.js';
+export { Migrator, MissingBlobs, BackupService, PlcOps, Restore, handleAndPDSResolver };
+//# sourceMappingURL=main.d.ts.map

packages/moover/types/main.d.ts.map

···
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../lib/main.js"],"names":[],"mappings":"yBAAuB,gBAAgB;6BACZ,mBAAmB;8BAClB,aAAa;uBACpB,cAAc;wBACb,cAAc;qCACD,mBAAmB"}

packages/moover/types/missingBlobs.d.ts

···
+/**
+ * Class to help find missing blobs from the did's previous PDS and import them into the current PDS
+ */
+export class MissingBlobs {
+    /**
+     * The user's current PDS agent
+     * @type {AtpAgent}
+     */
+    currentPdsAgent: AtpAgent;
+    /**
+     * The user's old PDS agent
+     * @type {AtpAgent}
+     */
+    oldPdsAgent: AtpAgent;
+    /**
+     * the user's did
+     * @type {string|null}
+     */
+    did: string | null;
+    /**
+     * The user's current PDS url
+     * @type {null}
+     */
+    currentPdsUrl: any;
+    /**
+     * A list of the missing cids blobs from the old PDS. In this case if a retry upload fails it gets put in this array for the ui
+     * @type {string[]}
+     */
+    missingBlobs: string[];
+    /**
+     * Logs the user into the current PDS and gets the account status
+     * @param handle {string}
+     * @param password {string}
+     * @param twoFactorCode {string|null}
+     * @returns {Promise<{accountStatus: OutputSchema, missingBlobsCount: number}>}
+     */
+    currentAgentLogin(handle: string, password: string, twoFactorCode?: string | null): Promise<{
+        accountStatus: OutputSchema;
+        missingBlobsCount: number;
+    }>;
+    /**
+     * Logs into the old PDS and gets the account status.
+     * Does not need a handle
+     * since it is assumed the user has already logged in with the current PDS and we are using their did
+     * @param password {string}
+     * @param twoFactorCode {string|null}
+     * @param pdsUrl {string|null} - If you know the url of the old PDS you can pass it in here. If not it will be guessed at from plc ops
+     * @returns {Promise<void>}
+     */
+    oldAgentLogin(password: string, twoFactorCode?: string | null, pdsUrl?: string | null): Promise<void>;
+    /**
+     * Gets the missing blobs from the old PDS and uploads them to the current PDS
+     * @param statusUpdateHandler {function} - A function to update the status of the migration. This is useful for showing the user the progress of the migration
+     * @returns {Promise<{accountStatus: OutputSchema, missingBlobsCount: number}>}
+     */
+    migrateMissingBlobs(statusUpdateHandler: Function): Promise<{
+        accountStatus: OutputSchema;
+        missingBlobsCount: number;
+    }>;
+}
+import { AtpAgent } from '@atproto/api';
+//# sourceMappingURL=missingBlobs.d.ts.map

packages/moover/types/missingBlobs.d.ts.map

···
+{"version":3,"file":"missingBlobs.d.ts","sourceRoot":"","sources":["../lib/missingBlobs.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAGQ;;;OAGG;IACH,iBAFU,QAAQ,CAES;IAC3B;;;OAGG;IACH,aAFU,QAAQ,CAEK;IACvB;;;OAGG;IACH,KAFU,MAAM,GAAC,IAAI,CAEN;IACf;;;OAGG;IACH,mBAAyB;IACzB;;;OAGG;IACH,cAFU,MAAM,EAAE,CAEI;IAI1B;;;;;;OAMG;IACH,0BALkB,MAAM,YACJ,MAAM,kBACD,MAAM,GAAC,IAAI,GACvB,OAAO,CAAC;QAAC,aAAa,EAAE,YAAY,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,CAAC,CA2B7E;IAED;;;;;;;;OAQG;IACH,wBALoB,MAAM,kBACD,MAAM,GAAC,IAAI,WAClB,MAAM,GAAC,IAAI,GAChB,OAAO,CAAC,IAAI,CAAC,CA+CzB;IAED;;;;OAIG;IACH,oDAFa,OAAO,CAAC;QAAC,aAAa,EAAE,YAAY,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,CAAC,CAyD7E;CAEJ;yBA9LsB,cAAc"}

packages/moover/types/pdsmoover.d.ts

···
+/**
+ * Handles normal PDS Migrations between two PDSs that are both up.
+ * On pdsmoover.com this is the logic for the MOOver
+ */
+export class Migrator {
+    /** @type {AtpAgent} */
+    oldAgent: AtpAgent;
+    /** @type {AtpAgent} */
+    newAgent: AtpAgent;
+    /** @type {[string]} */
+    missingBlobs: [string];
+    /** @type {boolean} */
+    createNewAccount: boolean;
+    /** @type {boolean} */
+    migrateRepo: boolean;
+    /** @type {boolean} */
+    migrateBlobs: boolean;
+    /** @type {boolean} */
+    migrateMissingBlobs: boolean;
+    /** @type {boolean} */
+    migratePrefs: boolean;
+    /** @type {boolean} */
+    migratePlcRecord: boolean;
+    /**
+     * This migrator is pretty cut and dry and makes a few assumptions
+     * 1. You are using the same password between each account
+     * 2. If this command fails for something like oauth 2fa code it throws an error and expects the same values when ran again.
+     * 3. You can control which "actions" happen by setting the class variables to false.
+     * 4. Each instance of the class is assumed to be for a single migration
+     * @param {string} oldHandle - The handle you use on your old pds, something like alice.bsky.social
+     * @param {string} password - Your password for your current login. Has to be your real password, no app password. When setting up a new account we reuse it as well for that account
+     * @param {string} newPdsUrl - The new URL for your pds. Like https://coolnewpds.com
+     * @param {string} newEmail - The email you want to use on the new pds (can be the same as the previous one as long as it's not already being used on the new pds)
+     * @param {string} newHandle - The new handle you want, like alice.bsky.social, or if you already have a domain name set as a handle can use it myname.com.
+     * @param {string|null} inviteCode - The invite code you got from the PDS you are migrating to. If null does not include one
+     * @param {function|null} statusUpdateHandler - a function that takes a string used to update the UI. Like (status) => console.log(status)
+     * @param {string|null} twoFactorCode - Optional, but needed if it fails with 2fa required
+     */
+    migrate(oldHandle: string, password: string, newPdsUrl: string, newEmail: string, newHandle: string, inviteCode: string | null, statusUpdateHandler?: Function | null, twoFactorCode?: string | null): Promise<void>;
+    /**
+     *  Sign and submits the PLC operation to officially migrate the account
+     * @param {string} token - the PLC token sent in the email. If you're just wanting to run this rerun migrate with all the flags set as false except for migratePlcRecord
+     * @param additionalRotationKeysToAdd {string[]} - additional rotation keys to add in addition to the ones provided by the new PDS.
+     * @returns {Promise<void>}
+     */
+    signPlcOperation(token: string, additionalRotationKeysToAdd?: string[]): Promise<void>;
+    /**
+     * Using this method assumes the Migrator class was constructed new and this was called.
+     * Find the user's previous PDS from the PLC op logs,
+     * logs in and deactivates their old account if it was found still active.
+     *
+     * @param oldHandle {string}
+     * @param oldPassword {string}
+     * @param {function|null} statusUpdateHandler - a function that takes a string used to update the UI.
+     * Like (status) => console.log(status)
+     * @param {string|null} twoFactorCode - Optional, but needed if it fails with 2fa required
+     * @returns {Promise<void>}
+     */
+    deactivateOldAccount(oldHandle: string, oldPassword: string, statusUpdateHandler?: Function | null, twoFactorCode?: string | null): Promise<void>;
+    /**
+     * Signs the logged-in user in this.newAgent for backups with PDS MOOver. This is usually called after migrate and signPlcOperation are successful
+     *
+     * @param {string} didWeb
+     * @returns {Promise<void>}
+     */
+    signUpForBackupsFromMigration(didWeb?: string): Promise<void>;
+}
+import { AtpAgent } from '@atproto/api';
+//# sourceMappingURL=pdsmoover.d.ts.map

packages/moover/types/pdsmoover.d.ts.map

···
+{"version":3,"file":"pdsmoover.d.ts","sourceRoot":"","sources":["../lib/pdsmoover.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAEQ,uBAAuB;IACvB,UADW,QAAQ,CACC;IACpB,uBAAuB;IACvB,UADW,QAAQ,CACC;IACpB,uBAAuB;IACvB,cADW,CAAC,MAAM,CAAC,CACG;IAEtB,sBAAsB;IACtB,kBADW,OAAO,CACU;IAC5B,sBAAsB;IACtB,aADW,OAAO,CACK;IACvB,sBAAsB;IACtB,cADW,OAAO,CACM;IACxB,sBAAsB;IACtB,qBADW,OAAO,CACa;IAC/B,sBAAsB;IACtB,cADW,OAAO,CACM;IACxB,sBAAsB;IACtB,kBADW,OAAO,CACU;IAGhC;;;;;;;;;;;;;;OAcG;IACH,mBATW,MAAM,YACN,MAAM,aACN,MAAM,YACN,MAAM,aACN,MAAM,cACN,MAAM,GAAC,IAAI,wBACX,WAAS,IAAI,kBACb,MAAM,GAAC,IAAI,iBAuLrB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,gCACsB,MAAM,EAAE,GAClC,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAED;;;;;;;;;;;OAWG;IACH,gCAPqB,MAAM,eACJ,MAAM,wBAClB,WAAS,IAAI,kBAEb,MAAM,GAAC,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,CAiEzB;IAED;;;;;OAKG;IACH,uCAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAkCzB;CACJ;yBAhYsB,cAAc"}

packages/moover/types/plc-ops.d.ts

···
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ */
+export type defs = typeof defs;
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ */
+export type normalizeOp = any;
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ */
+export type Operation = import("@atcute/did-plc").Operation;
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ */
+export type CompatibleOperation = import("@atcute/did-plc").CompatibleOperation;
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ */
+export type IndexedEntryLog = import("@atcute/did-plc").IndexedEntryLog;
+/**
+ * JSDoc type-only import to avoid runtime import errors in the browser.
+ */
+export type IndexedEntry = import("@atcute/did-plc").IndexedEntry;
+/**
+ * Class to help with various PLC operations
+ */
+export class PlcOps {
+    /**
+     *
+     * @param plcDirectoryUrl {string} - The url of the plc directory, defaults to https://plc.directory
+     */
+    constructor(plcDirectoryUrl?: string);
+    /**
+     * The url of the plc directory
+     * @type {string}
+     */
+    plcDirectoryUrl: string;
+    /**
+     *  Gets the current rotation keys for a user via their last PlC operation
+     * @param did
+     * @returns {Promise<string[]>}
+     */
+    getCurrentRotationKeysForUser(did: any): Promise<string[]>;
+    /**
+     *  Gets the last PlC operation for a user from the plc directory
+     * @param did
+     * @returns {Promise<{lastOperation: Operation, base: any}>}
+     */
+    getLastPlcOpFromPlc(did: any): Promise<{
+        lastOperation: Operation;
+        base: any;
+    }>;
+    /**
+     *
+     * @param logs {IndexedEntryLog}
+     * @returns {{lastOperation: Operation, base: IndexedEntry}}
+     */
+    getLastPlcOp(logs: IndexedEntryLog): {
+        lastOperation: Operation;
+        base: IndexedEntry;
+    };
+    /**
+     *  Gets the plc audit logs for a user from the plc directory
+     * @param did
+     * @returns {Promise<IndexedEntryLog>}
+     */
+    getPlcAuditLogs(did: any): Promise<IndexedEntryLog>;
+    /**
+     * Creates a new secp256k1 key that can be used for either rotation or verification key
+     * @returns {Promise<{privateKey: string, publicKey: `did:key:${string}`}>}
+     */
+    createANewSecp256k1(): Promise<{
+        privateKey: string;
+        publicKey: `did:key:${string}`;
+    }>;
+    /**
+     * Signs a new operation with the provided signing key, and information and submits it to the plc directory
+     * @param did {string} - The user's did
+     * @param signingRotationKey { P256PrivateKey|Secp256k1PrivateKey} - The keypair to sign the op with
+     * @param alsoKnownAs {string[]}
+     * @param rotationKeys {string[]}
+     * @param pds {string}
+     * @param verificationKey {string} - The public verification key
+     * @param prev {string} - The previous valid operation's cid.
+     * @returns {Promise<void>}
+     */
+    signAndPublishNewOp(did: string, signingRotationKey: P256PrivateKey | Secp256k1PrivateKey, alsoKnownAs: string[], rotationKeys: string[], pds: string, verificationKey: string, prev: string): Promise<void>;
+    /**
+     * Takes a multi or hex based private key and returns a keypair
+     * @param privateKeyString {string}
+     * @param type {string} - secp256k1 or p256, needed if the private key is hex based, can be assumed if it's a multikey
+     * @returns {Promise<{type: string, didPublicKey: `did:key:${string}`, keypair: P256PrivateKey|Secp256k1PrivateKey}>}
+     */
+    getKeyPair(privateKeyString: string, type?: string): Promise<{
+        type: string;
+        didPublicKey: `did:key:${string}`;
+        keypair: P256PrivateKey | Secp256k1PrivateKey;
+    }>;
+    /**
+     * Submits a new operation to the plc directory
+     * @param did {string} - The user's did
+     * @param operation
+     * @returns {Promise<void>}
+     */
+    pushPlcOperation(did: string, operation: any): Promise<void>;
+    /**
+     * Creates a new service auth token for a user. This is what is used to create a new account on a PDS for your did
+     *
+     * @param iss The user's did
+     * @param aud The did:web, if it's a PDS it's usually from /xrpc/com.atproto.server.describeServer
+     * @param keypair The keypair to sign with only supporting ES256K atm
+     * @param lxm The lxm which is usually com.atproto.server.createAccount for creating a new account
+     * @returns {Promise<string>}
+     */
+    createANewServiceAuthToken(iss: any, aud: any, keypair: any, lxm: any): Promise<string>;
+}
+import { defs } from '@atcute/did-plc';
+import { P256PrivateKey } from '@atcute/crypto';
+import { Secp256k1PrivateKey } from '@atcute/crypto';
+//# sourceMappingURL=plc-ops.d.ts.map

packages/moover/types/plc-ops.d.ts.map

···
+{"version":3,"file":"plc-ops.d.ts","sourceRoot":"","sources":["../lib/plc-ops.js"],"names":[],"mappings":";;;;;;;;;;;wBAIa,OAAO,iBAAiB,EAAE,SAAS;;;;kCACnC,OAAO,iBAAiB,EAAE,mBAAmB;;;;8BAC7C,OAAO,iBAAiB,EAAE,eAAe;;;;2BACzC,OAAO,iBAAiB,EAAE,YAAY;AAgBnD;;GAEG;AACH;IACI;;;OAGG;IACH,8BAF2B,MAAM,EAQhC;IALG;;;OAGG;IACH,iBAFU,MAAM,CAEsB;IAG1C;;;;OAIG;IACH,yCAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAAC;QAAC,aAAa,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAC,CAAC,CAK1D;IAED;;;;OAIG;IACH,mBAHgB,eAAe,GAClB;QAAC,aAAa,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,YAAY,CAAA;KAAC,CAK1D;IAGD;;;;OAIG;IACH,2BAFa,OAAO,CAAC,eAAe,CAAC,CAUpC;IAED;;;OAGG;IACH,uBAFa,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,WAAW,MAAM,EAAE,CAAA;KAAC,CAAC,CAUzE;IAGD;;;;;;;;;;OAUG;IACH,yBATe,MAAM,sBACU,cAAc,GAAC,mBAAmB,eAC1C,MAAM,EAAE,gBACP,MAAM,EAAE,OACjB,MAAM,mBACM,MAAM,QACjB,MAAM,GACT,OAAO,CAAC,IAAI,CAAC,CAuCzB;IAED;;;;;OAKG;IACH,6BAJ4B,MAAM,SAClB,MAAM,GACT,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,WAAW,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,cAAc,GAAC,mBAAmB,CAAA;KAAC,CAAC,CAkDnH;IAED;;;;;OAKG;IACH,sBAJe,MAAM,mBAER,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAGD;;;;;;;;OAQG;IACH,wEAFa,OAAO,CAAC,MAAM,CAAC,CAwC3B;CAGJ;qBAtR+B,iBAAiB;+BACsD,gBAAgB;oCAAhB,gBAAgB"}

packages/moover/types/restore.d.ts

···
+export type Operation = import("@atcute/did-plc").Operation;
+export class Restore {
+    /**
+     *
+     * @param pdsMooverInstance {string} - The url of the pds moover instance to restore from. Defaults to https://pdsmover.com
+     */
+    constructor(pdsMooverInstance?: string);
+    /**
+     * If you want to use a different plc directory create your own instance of the plc ops class and pass it in here
+     * @type {PlcOps} */
+    plcOps: PlcOps;
+    /**
+     * This is the base url for the pds moover instance used to restore the files from a backup.
+     * @type {string}
+     */
+    pdsMooverInstance: string;
+    /**
+     * To keep it simple, only uses secp256k for the temp verification key that is used to create the new account on the new PDS
+     * and is temporarily assigned to the user's account on PLC
+     * @type {null|Secp256k1PrivateKeyExportable}
+     */
+    tempVerificationKeypair: null | Secp256k1PrivateKeyExportable;
+    /** @type {AtpAgent} */
+    atpAgent: AtpAgent;
+    /**
+     * The keypair that is used to sign the plc operation
+     * @type {null|{type: string, didPublicKey: `did:key:${string}`, keypair: P256PrivateKey|Secp256k1PrivateKey}}
+     */
+    recoveryRotationKeyPair: null | {
+        type: string;
+        didPublicKey: `did:key:${string}`;
+        keypair: P256PrivateKey | Secp256k1PrivateKey;
+    };
+    /**
+     * If this is true we are just restoring the repo and blobs. Ideally for rerunning a restore process after account recovery
+     * @type {boolean}
+     */
+    RestoreFromBackup: boolean;
+    /**
+     * If set to true then it will do the account recovery. Writes a temp key to the did doc,
+     * create a new account on the new pds, and then submit a new plc op for the pds to have control (finishes the migration, can always restore the backup later)
+     * @type {boolean}
+     */
+    AccountRecovery: boolean;
+    /**
+     *  Recovers an account with the users rotation key and restores the repo from a PDS MOOver backup
+     *  This method can fail, and the account was still recovered, it's best to check the PLC logs to see where an account stands before reruns
+     * @param rotationKey {string} - The users private rotation key, can be a multi key or hex key
+     * @param rotationKeyType {string} - The type of the key, secp256k1 or p256. Required if the key is in hex format, defaults to secp256k1
+     * @param currentHandleOrDid {string} - The users current handle or did, if they don't have a DNS record it will have to be their did for success
+     * @param newPDS {string} - The new PDS url, like https://coolnewpds.com
+     * @param newHandle {string} - Can be the users DNS handle if it is already setup with their did, if not it's bob.mypds.com
+     * @param newPassword {string} - The new password for the new account
+     * @param newEmail {string} - The new email for the new account
+     * @param inviteCode {string|null} - The invite code for the new PDS if it requires one
+     * @param cidToRestoreTo {string|null} - The cid of the plc op to restore to, used mostly to revert a fraudulent plc op. Want to give it the last valid operations cid
+     * @param onStatus {function|null} - A function that takes a string used to update the UI. Like (status) => console.log(status)
+     * @returns {Promise<void>} If there is a failure during restoring the back up (after the status Success! Restoring your repo...) then your account is most likely
+     * recovered and future runs need to have the RestoreFromBackup flag set to true and AccountRecovery set to false.
+     */
+    recover(rotationKey: string, rotationKeyType: string, currentHandleOrDid: string, newPDS: string, newHandle: string, newPassword: string, newEmail: string, inviteCode: string | null, cidToRestoreTo?: string | null, onStatus?: Function | null): Promise<void>;
+    /**
+     * This method signs the plc operation over to the new PDS and activates the account
+     * Assumes you have already created a new account during the recovery process and logged in
+     * Uses the recommended did doc from the PDS as a base and adds the users rotation key to the rotation keys array
+     *
+     * @param usersDid
+     * @param additionalRotationKeysToAdd
+     * @param prevCid
+     * @returns {Promise<void>}
+     */
+    signRestorePlcOperation(usersDid: any, additionalRotationKeysToAdd: any[], prevCid: any): Promise<void>;
+}
+import { PlcOps } from './plc-ops.js';
+import { Secp256k1PrivateKeyExportable } from '@atcute/crypto';
+import { AtpAgent } from '@atproto/api';
+import { P256PrivateKey } from '@atcute/crypto';
+import { Secp256k1PrivateKey } from '@atcute/crypto';
+//# sourceMappingURL=restore.d.ts.map

packages/moover/types/restore.d.ts.map

···
+{"version":3,"file":"restore.d.ts","sourceRoot":"","sources":["../lib/restore.js"],"names":[],"mappings":"wBACa,OAAO,iBAAiB,EAAE,SAAS;AAWhD;IAEI;;;OAGG;IACH,gCAF6B,MAAM,EA0ClC;IAvCG;;wBAEoB;IACpB,QADU,MAAM,CACU;IAE1B;;;OAGG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;;OAIG;IACH,yBAFU,IAAI,GAAC,6BAA6B,CAET;IAEnC,uBAAuB;IACvB,UADW,QAAQ,CACC;IAEpB;;;OAGG;IACH,yBAFU,IAAI,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,WAAW,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,cAAc,GAAC,mBAAmB,CAAA;KAAC,CAE1E;IAEnC;;;OAGG;IACH,mBAFU,OAAO,CAEY;IAE7B;;;;OAIG;IACH,iBAFU,OAAO,CAEU;IAG/B;;;;;;;;;;;;;;;OAeG;IACH,qBAbuB,MAAM,mBACF,MAAM,sBACH,MAAM,UAClB,MAAM,aACH,MAAM,eACJ,MAAM,YACT,MAAM,cACJ,MAAM,GAAC,IAAI,mBACP,MAAM,GAAC,IAAI,aACjB,WAAS,IAAI,GACpB,OAAO,CAAC,IAAI,CAAC,CA4MzB;IAGD;;;;;;;;;OASG;IACH,0FAFa,OAAO,CAAC,IAAI,CAAC,CAuCzB;CACJ;uBAnUoB,cAAc;8CAGS,gBAAgB;yBADrC,cAAc;+BAJa,gBAAgB;oCAAhB,gBAAgB"}

packages/moover/vite.config.js

···
+import {dirname, resolve} from 'node:path'
+import {fileURLToPath} from 'node:url'
+import {defineConfig} from 'vite'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export default defineConfig({
+    build: {
+        lib: {
+            entry: resolve(__dirname, 'lib/main.js'),
+            name: '@pds-moover/moover',
+            // the proper extensions will be added
+            fileName: 'pds-moover',
+        },
+        rollupOptions: {
+            // // make sure to externalize deps that shouldn't be bundled
+            // // into your library
+            // external: ['vue'],
+            // output: {
+            //     // Provide global variables to use in the UMD build
+            //     // for externalized deps
+            //     globals: {
+            //         vue: 'Vue',
+            //     },
+            // },
+        },
+    },
+})

shared/src/db/models.rs

···
     pub created_at: DateTime<Utc>,
     pub account_did: String,
     pub size: i64,
-    pub blob_type: BlobType,
+    pub r#type: BlobType,
     pub cid_or_rev: String,
 }
 

shared/src/jobs/account_backup.rs

···
             .await
             .map_err(|e| Error::Failed(Arc::new(Box::new(e))))?;
 
-        let missing_cids = filter_missing_blob_cids(&pool, &resp.cids)
+        let missing_cids = filter_missing_blob_cids(&pool, &resp.cids, &job.did)
             .await
             .map_err(|e| Error::Failed(Arc::new(Box::new(AnyhowErrorWrapper(e)))))?;
 
         // Process missing CIDs in batches of 5
         let mut processed = 0;
 
-        //TODO need to fix where if it fails still tries the other 4 chunks
         for chunk in missing_cids.chunks(5) {
             processed += chunk.len();
             let last_chunk = processed >= missing_cids.len();

shared/src/jobs/mod.rs

···
 pub mod scheduled_back_up_start;
 pub mod start_all_backup;
 pub mod upload_blob;
+pub mod verify_backups;
 
 use crate::db::models;
 use crate::db::models::BlobModel;
···
 }
 
 /// Given a list of CIDs, returns those that are NOT already present in the blobs table
-/// with blob type = 'blob'. The returned order matches the input order and duplicates in the
-/// input are preserved if they are not present in the DB.
+/// with blob type = 'blob' and matches the user's did in the case of duplicate blobs for each user
 pub async fn filter_missing_blob_cids(
     pool: &Pool<Postgres>,
-    cids: &[String],
+    cids: &Vec<String>,
+    users_did: &String,
 ) -> anyhow::Result<Vec<String>> {
     if cids.is_empty() {
         return Ok(Vec::new());
···
 
     // Fetch the subset of provided CIDs that already exist as type 'blob'
     let existing: Vec<String> = sqlx::query_scalar(
-        r#"SELECT cid_or_rev FROM blobs WHERE type = $1 AND cid_or_rev = ANY($2)"#,
+        r#"SELECT cid_or_rev FROM blobs WHERE type = $1 AND cid_or_rev = ANY($2) AND account_did = $3"#,
     )
     .bind(crate::db::models::BlobType::Blob)
-    .bind(cids)
+    .bind(&cids)
+    .bind(users_did)
     .fetch_all(pool)
     .await?;
 
···
     size: i64,
     blob_type: models::BlobType,
 ) -> anyhow::Result<models::BlobModel> {
-    // For repo blobs, perform an upsert on the unique `cid` to avoid duplicate inserts
-    // and to refresh metadata if the same cid is seen again.
-    Ok(sqlx::query_as::<_, BlobModel>(
-        r#"
-            INSERT INTO blobs (account_did, size, type, cid_or_rev)
-            VALUES ($1, $2, $3, $4)
-            ON CONFLICT (cid_or_rev) DO UPDATE
-                SET account_did = EXCLUDED.account_did,
-                    size        = EXCLUDED.size,
-                    type        = EXCLUDED.type,
-                    cid_or_rev  = EXCLUDED.cid_or_rev
-            RETURNING id, created_at, account_did, size, type AS blob_type, cid_or_rev
-        "#,
-    )
-    .bind(did)
-    .bind(size)
-    .bind(blob_type)
-    .bind(cid_or_rev)
-    .fetch_one(pool)
-    .await?)
+    match blob_type {
+        //On repo we need to upsert on did
+        models::BlobType::Repo => {
+            // First try to update an existing 'repo' blob row for this DID.
+            if let Some(updated) = sqlx::query_as::<_, BlobModel>(
+                r#"
+                    UPDATE blobs
+                    SET size = $2,
+                        type = $3,
+                        cid_or_rev = $4
+                    WHERE account_did = $1 AND type = $3
+                    RETURNING id, created_at, account_did, size, type, cid_or_rev
+                "#,
+            )
+            .bind(&did)
+            .bind(size)
+            .bind(&blob_type)
+            .bind(&cid_or_rev)
+            .fetch_optional(pool)
+            .await?
+            {
+                Ok(updated)
+            } else {
+                // If no row was updated, insert a new one for this DID and repo type.
+                Ok(sqlx::query_as::<_, BlobModel>(
+                    r#"
+                        INSERT INTO blobs (account_did, size, type, cid_or_rev)
+                        VALUES ($1, $2, $3, $4)
+                        RETURNING id, created_at, account_did, size, type, cid_or_rev
+                    "#,
+                )
+                .bind(did)
+                .bind(size)
+                .bind(blob_type)
+                .bind(cid_or_rev)
+                .fetch_one(pool)
+                .await?)
+            }
+        }
+        //on blob we upsert on cid (shouldnt happen ideally)
+        models::BlobType::Blob | _ => Ok(sqlx::query_as::<_, BlobModel>(
+            r#"
+                    INSERT INTO blobs (account_did, size, type, cid_or_rev)
+                    VALUES ($1, $2, $3, $4)
+                    ON CONFLICT (cid_or_rev) DO UPDATE
+                        SET account_did = EXCLUDED.account_did,
+                            size        = EXCLUDED.size,
+                            type        = EXCLUDED.type,
+                            cid_or_rev  = EXCLUDED.cid_or_rev
+                    RETURNING id, created_at, account_did, size, type, cid_or_rev
+                "#,
+        )
+        .bind(did)
+        .bind(size)
+        .bind(blob_type)
+        .bind(cid_or_rev)
+        .fetch_one(pool)
+        .await?),
+    }
 }
 
 /// Look up the user's account by DID and return their repo_rev, if present.

shared/src/jobs/scheduled_back_up_start.rs

···
 pub struct ScheduledBackUpStartJobContext;
 
 /// This scheduled job finds:
-/// - accounts that have not been backed up in the last 24 hours and have pds_sign_up = false,
+/// - accounts that have not been backed up in the last 6 hours and have pds_sign_up = false,
 ///   and enqueues AccountBackup jobs for them;
-/// - pds_hosts that are active and have not started a backup in the last 24 hours (tracked via
+/// - pds_hosts that are active and have not started a backup in the last 6 hours (tracked via
 ///   pds_hosts.last_backup_start), and enqueues PdsBackup jobs for each.
 pub async fn scheduled_back_up_start_job(
     _job: ScheduledBackUpStartJobContext,
···
 ) -> Result<(), Error> {
     log::info!("Starting a backup for the whole instance");
     // Record the start of a whole-network backup run
-    sqlx::query(
-        r#"INSERT INTO network_backup_runs DEFAULT VALUES"#,
-    )
-    .execute(&*pool)
-    .await
-    .map_err(|e| Error::Failed(Arc::new(Box::new(e))))?;
+    sqlx::query(r#"INSERT INTO network_backup_runs DEFAULT VALUES"#)
+        .execute(&*pool)
+        .await
+        .map_err(|e| Error::Failed(Arc::new(Box::new(e))))?;
     // 1) Query accounts needing backup
-    // Condition: pds_sign_up = false AND (last_backup is NULL OR older than 24h)
+    // Condition: pds_sign_up = false AND (last_backup is NULL OR older than 6h)
     // We include did and pds_host to build AccountBackupJobContext
     let accounts: Vec<(String, String)> = sqlx::query_as(
         r#"
         SELECT did, pds_host
         FROM accounts
         WHERE pds_sign_up = FALSE
-          AND (last_backup IS NULL OR last_backup < NOW() - INTERVAL '24 HOURS')
+          AND (last_backup IS NULL OR last_backup < NOW() - INTERVAL '6 HOURS')
         "#,
     )
     .fetch_all(&*pool)
···
         SELECT pds_host
         FROM pds_hosts
         WHERE active = TRUE
-          AND (last_backup_start IS NULL OR last_backup_start < NOW() - INTERVAL '24 HOURS')
+          AND (last_backup_start IS NULL OR last_backup_start < NOW() - INTERVAL '6 HOURS')
         "#,
     )
     .fetch_all(&*pool)

shared/src/jobs/verify_backups.rs

···
+use crate::db::models::{BlobModel, BlobType};
+use crate::storage::{blob_backup_path, repo_backup_path};
+use anyhow::Result;
+use s3::Bucket;
+use sqlx::{Pool, Postgres};
+
+/// Verifies that all blobs in the database exist in S3.
+/// Returns a Vec of missing blob information (did, cid_or_rev, blob_type).
+pub async fn verify_backups(pool: &Pool<Postgres>, s3_bucket: &Bucket) -> Result<Vec<MissingBlob>> {
+    // Get all blobs from the database
+    let blobs = sqlx::query_as::<_, BlobModel>("SELECT * FROM blobs ORDER BY created_at")
+        .fetch_all(pool)
+        .await?;
+
+    let total_blobs = blobs.len();
+    log::info!("Checking {} blobs in S3...", total_blobs);
+
+    let mut missing_blobs = Vec::new();
+    let mut checked = 0;
+
+    for blob in blobs {
+        checked += 1;
+        if checked % 100 == 0 {
+            log::info!("Checked {}/{} blobs...", checked, total_blobs);
+        }
+
+        let s3_path = match blob.r#type {
+            BlobType::Repo => repo_backup_path(blob.account_did.clone()),
+            BlobType::Blob => blob_backup_path(blob.account_did.clone(), blob.cid_or_rev.clone()),
+            BlobType::Prefs => {
+                // Handle prefs if needed - for now skip
+                log::debug!("Skipping prefs blob: {:?}", blob);
+                continue;
+            }
+        };
+
+        // Check if the object exists in S3
+        match s3_bucket.head_object(&s3_path).await {
+            Ok(_) => {
+                // Object exists, all good
+                log::debug!("✓ Found: {}", s3_path);
+            }
+            Err(e) => {
+                // Check if it's a 404 error (not found)
+                if e.to_string().contains("404") {
+                    log::warn!("✗ Missing: {}", s3_path);
+                    missing_blobs.push(MissingBlob {
+                        did: blob.account_did.clone(),
+                        cid_or_rev: blob.cid_or_rev.clone(),
+                        blob_type: blob.r#type.clone(),
+                        s3_path,
+                    });
+                } else {
+                    // Some other error - log it but don't count as missing
+                    log::error!("Error checking {}: {}", s3_path, e);
+                }
+            }
+        }
+    }
+
+    log::info!(
+        "Verification complete. Checked {} blobs, found {} missing.",
+        checked,
+        missing_blobs.len()
+    );
+
+    Ok(missing_blobs)
+}
+
+#[derive(Debug, Clone)]
+pub struct MissingBlob {
+    pub did: String,
+    pub cid_or_rev: String,
+    pub blob_type: BlobType,
+    pub s3_path: String,
+}

web-ui/.gitignore

···
+node_modules
+
+# Output
+.output
+.vercel
+.netlify
+.wrangler
+/.svelte-kit
+/build
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Env
+.env.local
+.env.*
+!.env.example
+!.env.test
+
+# Vite
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*

web-ui/.npmrc

···
+engine-strict=true

web-ui/README.md

···
+# sv
+
+Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```sh
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```sh
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+## Building
+
+To create a production version of your app:
+
+```sh
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.

web-ui/bun.lock

···
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "web-ui",
+      "dependencies": {
+        "@atcute/client": "^4.0.5",
+        "@atcute/lexicons": "^1.2.2",
+        "@pds-moover/lexicons": "^1.0.1",
+        "@pds-moover/moover": "^1.0.0",
+      },
+      "devDependencies": {
+        "@eslint/compat": "^1.4.0",
+        "@eslint/js": "^9.36.0",
+        "@sveltejs/adapter-auto": "^6.1.0",
+        "@sveltejs/adapter-node": "^5.4.0",
+        "@sveltejs/kit": "^2.43.2",
+        "@sveltejs/vite-plugin-svelte": "^6.2.0",
+        "@types/node": "^22",
+        "eslint": "^9.36.0",
+        "eslint-plugin-svelte": "^3.12.4",
+        "globals": "^16.4.0",
+        "svelte": "^5.39.5",
+        "svelte-check": "^4.3.2",
+        "typescript": "^5.9.2",
+        "typescript-eslint": "^8.44.1",
+        "vite": "^7.1.7",
+      },
+    },
+  },
+  "packages": {
+    "@atcute/cbor": ["@atcute/cbor@2.2.7", "", { "dependencies": { "@atcute/cid": "^2.2.5", "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5" } }, "sha512-/mwAF0gnokOphceZqFq3uzMGdd8sbw5y6bxF8CRutRkCCUcpjjpJc5fkLwhxyGgOveF3mZuHE6p7t/+IAqb7Aw=="],
+
+    "@atcute/cid": ["@atcute/cid@2.2.6", "", { "dependencies": { "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5" } }, "sha512-bTAHHbJ24p+E//V4KCS4xdmd39o211jJswvqQOevj7vk+5IYcgDLx1ryZWZ1sEPOo9x875li/kj5gpKL14RDwQ=="],
+
+    "@atcute/client": ["@atcute/client@4.0.5", "", { "dependencies": { "@atcute/identity": "^1.1.1", "@atcute/lexicons": "^1.2.2" } }, "sha512-R8Qen8goGmEkynYGg2m6XFlVmz0GTDvQ+9w+4QqOob+XMk8/WDpF4aImev7WKEde/rV2gjcqW7zM8E6W9NShDA=="],
+
+    "@atcute/crypto": ["@atcute/crypto@2.2.5", "", { "dependencies": { "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5", "@noble/secp256k1": "^2.3.0" } }, "sha512-9CbQ9cJ68XewsbLrgdmWQS2uDD9D0hizWFJ3OOZ16TCuARREmzKEpFgHlMxPswR3bDxjwfiXzmYUlHaTqsnxRQ=="],
+
+    "@atcute/did-plc": ["@atcute/did-plc@0.1.7", "", { "dependencies": { "@atcute/cbor": "^2.2.6", "@atcute/cid": "^2.2.4", "@atcute/crypto": "^2.2.5", "@atcute/identity": "^1.1.1", "@atcute/lexicons": "^1.2.2", "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5", "@badrap/valita": "^0.4.6" } }, "sha512-a7yOQNqViae3rB5/xa3U0EPJbFD9l8zOHXx6XASZ5F8+Vy2uTgXK3omurpNZ5UxRpy1ni1AMhSohXr61cqWbkg=="],
+
+    "@atcute/identity": ["@atcute/identity@1.1.1", "", { "dependencies": { "@atcute/lexicons": "^1.2.2", "@badrap/valita": "^0.4.6" } }, "sha512-zax42n693VEhnC+5tndvO2KLDTMkHOz8UExwmklvJv7R9VujfEwiSWhcv6Jgwb3ellaG8wjiQ1lMOIjLLvwh0Q=="],
+
+    "@atcute/identity-resolver": ["@atcute/identity-resolver@1.1.4", "", { "dependencies": { "@atcute/lexicons": "^1.2.2", "@atcute/util-fetch": "^1.0.3", "@badrap/valita": "^0.4.6" }, "peerDependencies": { "@atcute/identity": "^1.0.0" } }, "sha512-/SVh8vf2cXFJenmBnGeYF2aY3WGQm3cJeew5NWTlkqoy3LvJ5wkvKq9PWu4Tv653VF40rPOp6LOdVr9Fa+q5rA=="],
+
+    "@atcute/lexicons": ["@atcute/lexicons@1.2.2", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "esm-env": "^1.2.2" } }, "sha512-bgEhJq5Z70/0TbK5sx+tAkrR8FsCODNiL2gUEvS5PuJfPxmFmRYNWaMGehxSPaXWpU2+Oa9ckceHiYbrItDTkA=="],
+
+    "@atcute/multibase": ["@atcute/multibase@1.1.6", "", { "dependencies": { "@atcute/uint8array": "^1.0.5" } }, "sha512-HBxuCgYLKPPxETV0Rot4VP9e24vKl8JdzGCZOVsDaOXJgbRZoRIF67Lp0H/OgnJeH/Xpva8Z5ReoTNJE5dn3kg=="],
+
+    "@atcute/uint8array": ["@atcute/uint8array@1.0.5", "", {}, "sha512-XLWWxoR2HNl2qU+FCr0rp1APwJXci7HnzbOQLxK55OaMNBXZ19+xNC5ii4QCsThsDxa4JS/JTzuiQLziITWf2Q=="],
+
+    "@atcute/util-fetch": ["@atcute/util-fetch@1.0.3", "", { "dependencies": { "@badrap/valita": "^0.4.6" } }, "sha512-f8zzTb/xlKIwv2OQ31DhShPUNCmIIleX6p7qIXwWwEUjX6x8skUtpdISSjnImq01LXpltGV5y8yhV4/Mlb7CRQ=="],
+
+    "@atproto/api": ["@atproto/api@0.16.11", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "@atproto/xrpc": "^0.7.5", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-1dhfQNHiclb102RW+Ea8Nft5olfqU0Ev/vlQaSX6mWNo1aP5zT+sPODJ8+BTUOYk3vcuvL7QMkqA/rLYy2PMyw=="],
+
+    "@atproto/common-web": ["@atproto/common-web@0.4.3", "", { "dependencies": { "graphemer": "^1.4.0", "multiformats": "^9.9.0", "uint8arrays": "3.0.0", "zod": "^3.23.8" } }, "sha512-nRDINmSe4VycJzPo6fP/hEltBcULFxt9Kw7fQk6405FyAWZiTluYHlXOnU7GkQfeUK44OENG1qFTBcmCJ7e8pg=="],
+
+    "@atproto/lexicon": ["@atproto/lexicon@0.5.1", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/syntax": "^0.4.1", "iso-datestring-validator": "^2.2.2", "multiformats": "^9.9.0", "zod": "^3.23.8" } }, "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A=="],
+
+    "@atproto/syntax": ["@atproto/syntax@0.4.1", "", {}, "sha512-CJdImtLAiFO+0z3BWTtxwk6aY5w4t8orHTMVJgkf++QRJWTxPbIFko/0hrkADB7n2EruDxDSeAgfUGehpH6ngw=="],
+
+    "@atproto/xrpc": ["@atproto/xrpc@0.7.5", "", { "dependencies": { "@atproto/lexicon": "^0.5.1", "zod": "^3.23.8" } }, "sha512-MUYNn5d2hv8yVegRL0ccHvTHAVj5JSnW07bkbiaz96UH45lvYNRVwt44z+yYVnb0/mvBzyD3/ZQ55TRGt7fHkA=="],
+
+    "@badrap/valita": ["@badrap/valita@0.4.6", "", {}, "sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.11", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.11", "", { "os": "android", "cpu": "arm" }, "sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.11", "", { "os": "android", "cpu": "arm64" }, "sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.11", "", { "os": "android", "cpu": "x64" }, "sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.11", "", { "os": "darwin", "cpu": "arm64" }, "sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.11", "", { "os": "darwin", "cpu": "x64" }, "sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.11", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.11", "", { "os": "freebsd", "cpu": "x64" }, "sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.11", "", { "os": "linux", "cpu": "arm" }, "sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.11", "", { "os": "linux", "cpu": "ia32" }, "sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.11", "", { "os": "linux", "cpu": "ppc64" }, "sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.11", "", { "os": "linux", "cpu": "s390x" }, "sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.11", "", { "os": "linux", "cpu": "x64" }, "sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.11", "", { "os": "none", "cpu": "arm64" }, "sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.11", "", { "os": "none", "cpu": "x64" }, "sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.11", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.11", "", { "os": "openbsd", "cpu": "x64" }, "sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.11", "", { "os": "none", "cpu": "arm64" }, "sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.11", "", { "os": "sunos", "cpu": "x64" }, "sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.11", "", { "os": "win32", "cpu": "arm64" }, "sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.11", "", { "os": "win32", "cpu": "ia32" }, "sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.11", "", { "os": "win32", "cpu": "x64" }, "sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA=="],
+
+    "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.9.0", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g=="],
+
+    "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.2", "", {}, "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew=="],
+
+    "@eslint/compat": ["@eslint/compat@1.4.0", "", { "dependencies": { "@eslint/core": "^0.16.0" }, "peerDependencies": { "eslint": "^8.40 || 9" }, "optionalPeers": ["eslint"] }, "sha512-DEzm5dKeDBPm3r08Ixli/0cmxr8LkRdwxMRUIJBlSCpAwSrvFEJpVBzV+66JhDxiaqKxnRzCXhtiMiczF7Hglg=="],
+
+    "@eslint/config-array": ["@eslint/config-array@0.21.1", "", { "dependencies": { "@eslint/object-schema": "^2.1.7", "debug": "^4.3.1", "minimatch": "^3.1.2" } }, "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA=="],
+
+    "@eslint/config-helpers": ["@eslint/config-helpers@0.4.1", "", { "dependencies": { "@eslint/core": "^0.16.0" } }, "sha512-csZAzkNhsgwb0I/UAV6/RGFTbiakPCf0ZrGmrIxQpYvGZ00PhTkSnyKNolphgIvmnJeGw6rcGVEXfTzUnFuEvw=="],
+
+    "@eslint/core": ["@eslint/core@0.16.0", "", { "dependencies": { "@types/json-schema": "^7.0.15" } }, "sha512-nmC8/totwobIiFcGkDza3GIKfAw1+hLiYVrh3I1nIomQ8PEr5cxg34jnkmGawul/ep52wGRAcyeDCNtWKSOj4Q=="],
+
+    "@eslint/eslintrc": ["@eslint/eslintrc@3.3.1", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^10.0.1", "globals": "^14.0.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ=="],
+
+    "@eslint/js": ["@eslint/js@9.38.0", "", {}, "sha512-UZ1VpFvXf9J06YG9xQBdnzU+kthors6KjhMAl6f4gH4usHyh31rUf2DLGInT8RFYIReYXNSydgPY0V2LuWgl7A=="],
+
+    "@eslint/object-schema": ["@eslint/object-schema@2.1.7", "", {}, "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA=="],
+
+    "@eslint/plugin-kit": ["@eslint/plugin-kit@0.4.0", "", { "dependencies": { "@eslint/core": "^0.16.0", "levn": "^0.4.1" } }, "sha512-sB5uyeq+dwCWyPi31B2gQlVlo+j5brPlWx4yZBrEaRo/nhdDE8Xke1gsGgtiBdaBTxuTkceLVuVt/pclrasb0A=="],
+
+    "@humanfs/core": ["@humanfs/core@0.19.1", "", {}, "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA=="],
+
+    "@humanfs/node": ["@humanfs/node@0.16.7", "", { "dependencies": { "@humanfs/core": "^0.19.1", "@humanwhocodes/retry": "^0.4.0" } }, "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ=="],
+
+    "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="],
+
+    "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
+
+    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
+
+    "@noble/secp256k1": ["@noble/secp256k1@2.3.0", "", {}, "sha512-0TQed2gcBbIrh7Ccyw+y/uZQvbJwm7Ao4scBUxqpBCcsOlZG0O4KGfjtNAy/li4W8n1xt3dxrwJ0beZ2h2G6Kw=="],
+
+    "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
+
+    "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
+
+    "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
+
+    "@pds-moover/lexicons": ["@pds-moover/lexicons@1.0.1", "", { "dependencies": { "@atproto/lexicon": "^0.5.1", "@atproto/xrpc": "^0.7.5" } }, "sha512-fv5b/DtHM7FEo/JklyF9gdK0ainlb6mWjWrBe6cmSAeg9G/4O2jBlQUOqfOAICY9gOcrCpkOrk9PHgGw//JQ2A=="],
+
+    "@pds-moover/moover": ["@pds-moover/moover@1.0.0", "", { "dependencies": { "@atcute/cbor": "^2.2.7", "@atcute/client": "^4.0.4", "@atcute/crypto": "^2.2.5", "@atcute/did-plc": "^0.1.7", "@atcute/identity-resolver": "^1.1.3", "@atcute/lexicons": "^1.2.2", "@atcute/multibase": "^1.1.6", "@atproto/api": "^0.16.7", "@pds-moover/lexicons": "^1.0.0", "alpinejs": "^3.15.0", "vite-plugin-full-reload": "^1.2.0", "vite-rs-plugin": "1.0.1" } }, "sha512-RTwxM7K8M3PbFladdrnMv2N7qNz5ikWR/trw3wipijDfZl7VcpvPlFliEhIO1JqHnr2PTRc9ORXQsFGgCjSmRg=="],
+
+    "@polka/url": ["@polka/url@1.0.0-next.29", "", {}, "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww=="],
+
+    "@rollup/plugin-commonjs": ["@rollup/plugin-commonjs@28.0.9", "", { "dependencies": { "@rollup/pluginutils": "^5.0.1", "commondir": "^1.0.1", "estree-walker": "^2.0.2", "fdir": "^6.2.0", "is-reference": "1.2.1", "magic-string": "^0.30.3", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^2.68.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-PIR4/OHZ79romx0BVVll/PkwWpJ7e5lsqFa3gFfcrFPWwLXLV39JVUzQV9RKjWerE7B845Hqjj9VYlQeieZ2dA=="],
+
+    "@rollup/plugin-json": ["@rollup/plugin-json@6.1.0", "", { "dependencies": { "@rollup/pluginutils": "^5.1.0" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-EGI2te5ENk1coGeADSIwZ7G2Q8CJS2sF120T7jLw4xFw9n7wIOXHo+kIYRAoVpJAN+kmqZSoO3Fp4JtoNF4ReA=="],
+
+    "@rollup/plugin-node-resolve": ["@rollup/plugin-node-resolve@16.0.3", "", { "dependencies": { "@rollup/pluginutils": "^5.0.1", "@types/resolve": "1.20.2", "deepmerge": "^4.2.2", "is-module": "^1.0.0", "resolve": "^1.22.1" }, "peerDependencies": { "rollup": "^2.78.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-lUYM3UBGuM93CnMPG1YocWu7X802BrNF3jW2zny5gQyLQgRFJhV1Sq0Zi74+dh/6NBx1DxFC4b4GXg9wUCG5Qg=="],
+
+    "@rollup/pluginutils": ["@rollup/pluginutils@5.3.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.52.5", "", { "os": "android", "cpu": "arm" }, "sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.52.5", "", { "os": "android", "cpu": "arm64" }, "sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.52.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.52.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.52.5", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.52.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.52.5", "", { "os": "linux", "cpu": "arm" }, "sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.52.5", "", { "os": "linux", "cpu": "arm" }, "sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.52.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.52.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q=="],
+
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.52.5", "", { "os": "linux", "cpu": "none" }, "sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.52.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.52.5", "", { "os": "linux", "cpu": "none" }, "sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.52.5", "", { "os": "linux", "cpu": "none" }, "sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.52.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.52.5", "", { "os": "linux", "cpu": "x64" }, "sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.52.5", "", { "os": "linux", "cpu": "x64" }, "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg=="],
+
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.52.5", "", { "os": "none", "cpu": "arm64" }, "sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.52.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.52.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.52.5", "", { "os": "win32", "cpu": "x64" }, "sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.52.5", "", { "os": "win32", "cpu": "x64" }, "sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg=="],
+
+    "@standard-schema/spec": ["@standard-schema/spec@1.0.0", "", {}, "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA=="],
+
+    "@sveltejs/acorn-typescript": ["@sveltejs/acorn-typescript@1.0.6", "", { "peerDependencies": { "acorn": "^8.9.0" } }, "sha512-4awhxtMh4cx9blePWl10HRHj8Iivtqj+2QdDCSMDzxG+XKa9+VCNupQuCuvzEhYPzZSrX+0gC+0lHA/0fFKKQQ=="],
+
+    "@sveltejs/adapter-auto": ["@sveltejs/adapter-auto@6.1.1", "", { "peerDependencies": { "@sveltejs/kit": "^2.0.0" } }, "sha512-cBNt4jgH4KuaNO5gRSB2CZKkGtz+OCZ8lPjRQGjhvVUD4akotnj2weUia6imLl2v07K3IgsQRyM36909miSwoQ=="],
+
+    "@sveltejs/adapter-node": ["@sveltejs/adapter-node@5.4.0", "", { "dependencies": { "@rollup/plugin-commonjs": "^28.0.1", "@rollup/plugin-json": "^6.1.0", "@rollup/plugin-node-resolve": "^16.0.0", "rollup": "^4.9.5" }, "peerDependencies": { "@sveltejs/kit": "^2.4.0" } }, "sha512-NMsrwGVPEn+J73zH83Uhss/hYYZN6zT3u31R3IHAn3MiKC3h8fjmIAhLfTSOeNHr5wPYfjjMg8E+1gyFgyrEcQ=="],
+
+    "@sveltejs/kit": ["@sveltejs/kit@2.48.0", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "@sveltejs/acorn-typescript": "^1.0.5", "@types/cookie": "^0.6.0", "acorn": "^8.14.1", "cookie": "^0.6.0", "devalue": "^5.3.2", "esm-env": "^1.2.2", "kleur": "^4.1.5", "magic-string": "^0.30.5", "mrmime": "^2.0.0", "sade": "^1.8.1", "set-cookie-parser": "^2.6.0", "sirv": "^3.0.0" }, "peerDependencies": { "@opentelemetry/api": "^1.0.0", "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0 || ^6.0.0-next.0", "svelte": "^4.0.0 || ^5.0.0-next.0", "vite": "^5.0.3 || ^6.0.0 || ^7.0.0-beta.0" }, "optionalPeers": ["@opentelemetry/api"], "bin": { "svelte-kit": "svelte-kit.js" } }, "sha512-GAAbkWrbRJvysL7+HOWs5v/+TmnRcEQPeED2sUcDFTHpPvRYADEtScL6x8hWuKp0DKauJVaVJLTjQVy9e7cMiw=="],
+
+    "@sveltejs/vite-plugin-svelte": ["@sveltejs/vite-plugin-svelte@6.2.1", "", { "dependencies": { "@sveltejs/vite-plugin-svelte-inspector": "^5.0.0", "debug": "^4.4.1", "deepmerge": "^4.3.1", "magic-string": "^0.30.17", "vitefu": "^1.1.1" }, "peerDependencies": { "svelte": "^5.0.0", "vite": "^6.3.0 || ^7.0.0" } }, "sha512-YZs/OSKOQAQCnJvM/P+F1URotNnYNeU3P2s4oIpzm1uFaqUEqRxUB0g5ejMjEb5Gjb9/PiBI5Ktrq4rUUF8UVQ=="],
+
+    "@sveltejs/vite-plugin-svelte-inspector": ["@sveltejs/vite-plugin-svelte-inspector@5.0.1", "", { "dependencies": { "debug": "^4.4.1" }, "peerDependencies": { "@sveltejs/vite-plugin-svelte": "^6.0.0-next.0", "svelte": "^5.0.0", "vite": "^6.3.0 || ^7.0.0" } }, "sha512-ubWshlMk4bc8mkwWbg6vNvCeT7lGQojE3ijDh3QTR6Zr/R+GXxsGbyH4PExEPpiFmqPhYiVSVmHBjUcVc1JIrA=="],
+
+    "@types/cookie": ["@types/cookie@0.6.0", "", {}, "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA=="],
+
+    "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
+
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
+    "@types/node": ["@types/node@22.18.12", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-BICHQ67iqxQGFSzfCFTT7MRQ5XcBjG5aeKh5Ok38UBbPe5fxTyE+aHFxwVrGyr8GNlqFMLKD1D3P2K/1ks8tog=="],
+
+    "@types/resolve": ["@types/resolve@1.20.2", "", {}, "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q=="],
+
+    "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@8.46.2", "", { "dependencies": { "@eslint-community/regexpp": "^4.10.0", "@typescript-eslint/scope-manager": "8.46.2", "@typescript-eslint/type-utils": "8.46.2", "@typescript-eslint/utils": "8.46.2", "@typescript-eslint/visitor-keys": "8.46.2", "graphemer": "^1.4.0", "ignore": "^7.0.0", "natural-compare": "^1.4.0", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "@typescript-eslint/parser": "^8.46.2", "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-ZGBMToy857/NIPaaCucIUQgqueOiq7HeAKkhlvqVV4lm089zUFW6ikRySx2v+cAhKeUCPuWVHeimyk6Dw1iY3w=="],
+
+    "@typescript-eslint/parser": ["@typescript-eslint/parser@8.46.2", "", { "dependencies": { "@typescript-eslint/scope-manager": "8.46.2", "@typescript-eslint/types": "8.46.2", "@typescript-eslint/typescript-estree": "8.46.2", "@typescript-eslint/visitor-keys": "8.46.2", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-BnOroVl1SgrPLywqxyqdJ4l3S2MsKVLDVxZvjI1Eoe8ev2r3kGDo+PcMihNmDE+6/KjkTubSJnmqGZZjQSBq/g=="],
+
+    "@typescript-eslint/project-service": ["@typescript-eslint/project-service@8.46.2", "", { "dependencies": { "@typescript-eslint/tsconfig-utils": "^8.46.2", "@typescript-eslint/types": "^8.46.2", "debug": "^4.3.4" }, "peerDependencies": { "typescript": ">=4.8.4 <6.0.0" } }, "sha512-PULOLZ9iqwI7hXcmL4fVfIsBi6AN9YxRc0frbvmg8f+4hQAjQ5GYNKK0DIArNo+rOKmR/iBYwkpBmnIwin4wBg=="],
+
+    "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@8.46.2", "", { "dependencies": { "@typescript-eslint/types": "8.46.2", "@typescript-eslint/visitor-keys": "8.46.2" } }, "sha512-LF4b/NmGvdWEHD2H4MsHD8ny6JpiVNDzrSZr3CsckEgCbAGZbYM4Cqxvi9L+WqDMT+51Ozy7lt2M+d0JLEuBqA=="],
+
+    "@typescript-eslint/tsconfig-utils": ["@typescript-eslint/tsconfig-utils@8.46.2", "", { "peerDependencies": { "typescript": ">=4.8.4 <6.0.0" } }, "sha512-a7QH6fw4S57+F5y2FIxxSDyi5M4UfGF+Jl1bCGd7+L4KsaUY80GsiF/t0UoRFDHAguKlBaACWJRmdrc6Xfkkag=="],
+
+    "@typescript-eslint/type-utils": ["@typescript-eslint/type-utils@8.46.2", "", { "dependencies": { "@typescript-eslint/types": "8.46.2", "@typescript-eslint/typescript-estree": "8.46.2", "@typescript-eslint/utils": "8.46.2", "debug": "^4.3.4", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-HbPM4LbaAAt/DjxXaG9yiS9brOOz6fabal4uvUmaUYe6l3K1phQDMQKBRUrr06BQkxkvIZVVHttqiybM9nJsLA=="],
+
+    "@typescript-eslint/types": ["@typescript-eslint/types@8.46.2", "", {}, "sha512-lNCWCbq7rpg7qDsQrd3D6NyWYu+gkTENkG5IKYhUIcxSb59SQC/hEQ+MrG4sTgBVghTonNWq42bA/d4yYumldQ=="],
+
+    "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@8.46.2", "", { "dependencies": { "@typescript-eslint/project-service": "8.46.2", "@typescript-eslint/tsconfig-utils": "8.46.2", "@typescript-eslint/types": "8.46.2", "@typescript-eslint/visitor-keys": "8.46.2", "debug": "^4.3.4", "fast-glob": "^3.3.2", "is-glob": "^4.0.3", "minimatch": "^9.0.4", "semver": "^7.6.0", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "typescript": ">=4.8.4 <6.0.0" } }, "sha512-f7rW7LJ2b7Uh2EiQ+7sza6RDZnajbNbemn54Ob6fRwQbgcIn+GWfyuHDHRYgRoZu1P4AayVScrRW+YfbTvPQoQ=="],
+
+    "@typescript-eslint/utils": ["@typescript-eslint/utils@8.46.2", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.7.0", "@typescript-eslint/scope-manager": "8.46.2", "@typescript-eslint/types": "8.46.2", "@typescript-eslint/typescript-estree": "8.46.2" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-sExxzucx0Tud5tE0XqR0lT0psBQvEpnpiul9XbGUB1QwpWJJAps1O/Z7hJxLGiZLBKMCutjTzDgmd1muEhBnVg=="],
+
+    "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.46.2", "", { "dependencies": { "@typescript-eslint/types": "8.46.2", "eslint-visitor-keys": "^4.2.1" } }, "sha512-tUFMXI4gxzzMXt4xpGJEsBsTox0XbNQ1y94EwlD/CuZwFcQP79xfQqMhau9HsRc/J0cAPA/HZt1dZPtGn9V/7w=="],
+
+    "@vue/reactivity": ["@vue/reactivity@3.1.5", "", { "dependencies": { "@vue/shared": "3.1.5" } }, "sha512-1tdfLmNjWG6t/CsPldh+foumYFo3cpyCHgBYQ34ylaMsJ+SNHQ1kApMIa8jN+i593zQuaw3AdWH0nJTARzCFhg=="],
+
+    "@vue/shared": ["@vue/shared@3.1.5", "", {}, "sha512-oJ4F3TnvpXaQwZJNF3ZK+kLPHKarDmJjJ6jyzVNDKH9md1dptjC7lWR//jrGuLdek/U6iltWxqAnYOu8gCiOvA=="],
+
+    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
+    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
+
+    "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="],
+
+    "alpinejs": ["alpinejs@3.15.1", "", { "dependencies": { "@vue/reactivity": "~3.1.1" } }, "sha512-HLO1TtiE92VajFHtLLPK8BWaK1YepV/uj31UrfoGnQ00lyFOJZ+oVY3F0DghPAwvg8sLU79pmjGQSytERa2gEg=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
+
+    "aria-query": ["aria-query@5.3.2", "", {}, "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw=="],
+
+    "await-lock": ["await-lock@2.2.2", "", {}, "sha512-aDczADvlvTGajTDjcjpJMqRkOF6Qdz3YbPZm/PyW6tKPkx2hlYBzxMhEywM/tU72HrVZjgl5VCdRuMlA7pZ8Gw=="],
+
+    "axobject-query": ["axobject-query@4.1.0", "", {}, "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ=="],
+
+    "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
+
+    "brace-expansion": ["brace-expansion@1.1.12", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg=="],
+
+    "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
+
+    "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="],
+
+    "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
+
+    "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "commondir": ["commondir@1.0.1", "", {}, "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg=="],
+
+    "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="],
+
+    "cookie": ["cookie@0.6.0", "", {}, "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw=="],
+
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+
+    "cssesc": ["cssesc@3.0.0", "", { "bin": { "cssesc": "bin/cssesc" } }, "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="],
+
+    "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="],
+
+    "devalue": ["devalue@5.4.2", "", {}, "sha512-MwPZTKEPK2k8Qgfmqrd48ZKVvzSQjgW0lXLxiIBA8dQjtf/6mw6pggHNLcyDKyf+fI6eXxlQwPsfaCMTU5U+Bw=="],
+
+    "esbuild": ["esbuild@0.25.11", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.11", "@esbuild/android-arm": "0.25.11", "@esbuild/android-arm64": "0.25.11", "@esbuild/android-x64": "0.25.11", "@esbuild/darwin-arm64": "0.25.11", "@esbuild/darwin-x64": "0.25.11", "@esbuild/freebsd-arm64": "0.25.11", "@esbuild/freebsd-x64": "0.25.11", "@esbuild/linux-arm": "0.25.11", "@esbuild/linux-arm64": "0.25.11", "@esbuild/linux-ia32": "0.25.11", "@esbuild/linux-loong64": "0.25.11", "@esbuild/linux-mips64el": "0.25.11", "@esbuild/linux-ppc64": "0.25.11", "@esbuild/linux-riscv64": "0.25.11", "@esbuild/linux-s390x": "0.25.11", "@esbuild/linux-x64": "0.25.11", "@esbuild/netbsd-arm64": "0.25.11", "@esbuild/netbsd-x64": "0.25.11", "@esbuild/openbsd-arm64": "0.25.11", "@esbuild/openbsd-x64": "0.25.11", "@esbuild/openharmony-arm64": "0.25.11", "@esbuild/sunos-x64": "0.25.11", "@esbuild/win32-arm64": "0.25.11", "@esbuild/win32-ia32": "0.25.11", "@esbuild/win32-x64": "0.25.11" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q=="],
+
+    "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
+
+    "eslint": ["eslint@9.38.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", "@eslint/config-array": "^0.21.1", "@eslint/config-helpers": "^0.4.1", "@eslint/core": "^0.16.0", "@eslint/eslintrc": "^3.3.1", "@eslint/js": "9.38.0", "@eslint/plugin-kit": "^0.4.0", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^8.4.0", "eslint-visitor-keys": "^4.2.1", "espree": "^10.4.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-t5aPOpmtJcZcz5UJyY2GbvpDlsK5E8JqRqoKtfiKE3cNh437KIqfJr3A3AKf5k64NPx6d0G3dno6XDY05PqPtw=="],
+
+    "eslint-plugin-svelte": ["eslint-plugin-svelte@3.12.5", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.6.1", "@jridgewell/sourcemap-codec": "^1.5.0", "esutils": "^2.0.3", "globals": "^16.0.0", "known-css-properties": "^0.37.0", "postcss": "^8.4.49", "postcss-load-config": "^3.1.4", "postcss-safe-parser": "^7.0.0", "semver": "^7.6.3", "svelte-eslint-parser": "^1.4.0" }, "peerDependencies": { "eslint": "^8.57.1 || ^9.0.0", "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0" }, "optionalPeers": ["svelte"] }, "sha512-4KRG84eAHQfYd9OjZ1K7sCHy0nox+9KwT+s5WCCku3jTim5RV4tVENob274nCwIaApXsYPKAUAZFBxKZ3Wyfjw=="],
+
+    "eslint-scope": ["eslint-scope@8.4.0", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg=="],
+
+    "eslint-visitor-keys": ["eslint-visitor-keys@4.2.1", "", {}, "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ=="],
+
+    "esm-env": ["esm-env@1.2.2", "", {}, "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA=="],
+
+    "espree": ["espree@10.4.0", "", { "dependencies": { "acorn": "^8.15.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^4.2.1" } }, "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ=="],
+
+    "esquery": ["esquery@1.6.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg=="],
+
+    "esrap": ["esrap@2.1.1", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.4.15" } }, "sha512-ebTT9B6lOtZGMgJ3o5r12wBacHctG7oEWazIda8UlPfA3HD/Wrv8FdXoVo73vzdpwCxNyXjPauyN2bbJzMkB9A=="],
+
+    "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="],
+
+    "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
+
+    "estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="],
+
+    "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="],
+
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
+
+    "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="],
+
+    "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="],
+
+    "fastq": ["fastq@1.19.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ=="],
+
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "file-entry-cache": ["file-entry-cache@8.0.0", "", { "dependencies": { "flat-cache": "^4.0.0" } }, "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ=="],
+
+    "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
+
+    "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="],
+
+    "flat-cache": ["flat-cache@4.0.1", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" } }, "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw=="],
+
+    "flatted": ["flatted@3.3.3", "", {}, "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
+
+    "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
+
+    "globals": ["globals@16.4.0", "", {}, "sha512-ob/2LcVVaVGCYN+r14cnwnoDPUufjiYgSqRhiFD0Q1iI4Odora5RE8Iv1D24hAz5oMophRGkGz+yuvQmmUMnMw=="],
+
+    "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="],
+
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
+
+    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
+
+    "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
+
+    "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="],
+
+    "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="],
+
+    "is-core-module": ["is-core-module@2.16.1", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w=="],
+
+    "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
+
+    "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
+
+    "is-module": ["is-module@1.0.0", "", {}, "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g=="],
+
+    "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
+
+    "is-reference": ["is-reference@3.0.3", "", { "dependencies": { "@types/estree": "^1.0.6" } }, "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw=="],
+
+    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
+
+    "iso-datestring-validator": ["iso-datestring-validator@2.2.2", "", {}, "sha512-yLEMkBbLZTlVQqOnQ4FiMujR6T4DEcCb1xizmvXS+OxuhwcbtynoosRzdMA69zZCShCNAbi+gJ71FxZBBXx1SA=="],
+
+    "js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="],
+
+    "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="],
+
+    "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="],
+
+    "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="],
+
+    "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="],
+
+    "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
+
+    "known-css-properties": ["known-css-properties@0.37.0", "", {}, "sha512-JCDrsP4Z1Sb9JwG0aJ8Eo2r7k4Ou5MwmThS/6lcIe1ICyb7UBJKGRIUUdqc2ASdE/42lgz6zFUnzAIhtXnBVrQ=="],
+
+    "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="],
+
+    "lilconfig": ["lilconfig@2.1.0", "", {}, "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ=="],
+
+    "locate-character": ["locate-character@3.0.0", "", {}, "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA=="],
+
+    "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
+
+    "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="],
+
+    "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
+
+    "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+
+    "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
+
+    "minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="],
+
+    "mri": ["mri@1.2.0", "", {}, "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA=="],
+
+    "mrmime": ["mrmime@2.0.1", "", {}, "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="],
+
+    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="],
+
+    "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="],
+
+    "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
+
+    "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
+
+    "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="],
+
+    "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
+
+    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+
+    "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+
+    "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
+
+    "postcss-load-config": ["postcss-load-config@3.1.4", "", { "dependencies": { "lilconfig": "^2.0.5", "yaml": "^1.10.2" }, "peerDependencies": { "postcss": ">=8.0.9", "ts-node": ">=9.0.0" }, "optionalPeers": ["postcss", "ts-node"] }, "sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg=="],
+
+    "postcss-safe-parser": ["postcss-safe-parser@7.0.1", "", { "peerDependencies": { "postcss": "^8.4.31" } }, "sha512-0AioNCJZ2DPYz5ABT6bddIqlhgwhpHZ/l65YAYo0BCIn0xiDpsnTHz0gnoTGk0OXZW0JRs+cDwL8u/teRdz+8A=="],
+
+    "postcss-scss": ["postcss-scss@4.0.9", "", { "peerDependencies": { "postcss": "^8.4.29" } }, "sha512-AjKOeiwAitL/MXxQW2DliT28EKukvvbEWx3LBmJIRN8KfBGZbRTxNYW0kSqi1COiTZ57nZ9NW06S6ux//N1c9A=="],
+
+    "postcss-selector-parser": ["postcss-selector-parser@7.1.0", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA=="],
+
+    "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="],
+
+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
+    "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
+
+    "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
+
+    "resolve": ["resolve@1.22.11", "", { "dependencies": { "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ=="],
+
+    "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
+
+    "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
+
+    "rollup": ["rollup@4.52.5", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.52.5", "@rollup/rollup-android-arm64": "4.52.5", "@rollup/rollup-darwin-arm64": "4.52.5", "@rollup/rollup-darwin-x64": "4.52.5", "@rollup/rollup-freebsd-arm64": "4.52.5", "@rollup/rollup-freebsd-x64": "4.52.5", "@rollup/rollup-linux-arm-gnueabihf": "4.52.5", "@rollup/rollup-linux-arm-musleabihf": "4.52.5", "@rollup/rollup-linux-arm64-gnu": "4.52.5", "@rollup/rollup-linux-arm64-musl": "4.52.5", "@rollup/rollup-linux-loong64-gnu": "4.52.5", "@rollup/rollup-linux-ppc64-gnu": "4.52.5", "@rollup/rollup-linux-riscv64-gnu": "4.52.5", "@rollup/rollup-linux-riscv64-musl": "4.52.5", "@rollup/rollup-linux-s390x-gnu": "4.52.5", "@rollup/rollup-linux-x64-gnu": "4.52.5", "@rollup/rollup-linux-x64-musl": "4.52.5", "@rollup/rollup-openharmony-arm64": "4.52.5", "@rollup/rollup-win32-arm64-msvc": "4.52.5", "@rollup/rollup-win32-ia32-msvc": "4.52.5", "@rollup/rollup-win32-x64-gnu": "4.52.5", "@rollup/rollup-win32-x64-msvc": "4.52.5", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw=="],
+
+    "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
+
+    "sade": ["sade@1.8.1", "", { "dependencies": { "mri": "^1.1.0" } }, "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A=="],
+
+    "semver": ["semver@7.7.3", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q=="],
+
+    "set-cookie-parser": ["set-cookie-parser@2.7.1", "", {}, "sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ=="],
+
+    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
+
+    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
+
+    "sirv": ["sirv@3.0.2", "", { "dependencies": { "@polka/url": "^1.0.0-next.24", "mrmime": "^2.0.0", "totalist": "^3.0.0" } }, "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
+
+    "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="],
+
+    "svelte": ["svelte@5.42.2", "", { "dependencies": { "@jridgewell/remapping": "^2.3.4", "@jridgewell/sourcemap-codec": "^1.5.0", "@sveltejs/acorn-typescript": "^1.0.5", "@types/estree": "^1.0.5", "acorn": "^8.12.1", "aria-query": "^5.3.1", "axobject-query": "^4.1.0", "clsx": "^2.1.1", "esm-env": "^1.2.1", "esrap": "^2.1.0", "is-reference": "^3.0.3", "locate-character": "^3.0.0", "magic-string": "^0.30.11", "zimmerframe": "^1.1.2" } }, "sha512-iSry5jsBHispVczyt9UrBX/1qu3HQ/UyKPAIjqlvlu3o/eUvc+kpyMyRS2O4HLLx4MvLurLGIUOyyP11pyD59g=="],
+
+    "svelte-check": ["svelte-check@4.3.3", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.25", "chokidar": "^4.0.1", "fdir": "^6.2.0", "picocolors": "^1.0.0", "sade": "^1.7.4" }, "peerDependencies": { "svelte": "^4.0.0 || ^5.0.0-next.0", "typescript": ">=5.0.0" }, "bin": { "svelte-check": "bin/svelte-check" } }, "sha512-RYP0bEwenDXzfv0P1sKAwjZSlaRyqBn0Fz1TVni58lqyEiqgwztTpmodJrGzP6ZT2aHl4MbTvWP6gbmQ3FOnBg=="],
+
+    "svelte-eslint-parser": ["svelte-eslint-parser@1.4.0", "", { "dependencies": { "eslint-scope": "^8.2.0", "eslint-visitor-keys": "^4.0.0", "espree": "^10.0.0", "postcss": "^8.4.49", "postcss-scss": "^4.0.9", "postcss-selector-parser": "^7.0.0" }, "peerDependencies": { "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0" }, "optionalPeers": ["svelte"] }, "sha512-fjPzOfipR5S7gQ/JvI9r2H8y9gMGXO3JtmrylHLLyahEMquXI0lrebcjT+9/hNgDej0H7abTyox5HpHmW1PSWA=="],
+
+    "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="],
+
+    "tlds": ["tlds@1.261.0", "", { "bin": { "tlds": "bin.js" } }, "sha512-QXqwfEl9ddlGBaRFXIvNKK6OhipSiLXuRuLJX5DErz0o0Q0rYxulWLdFryTkV5PkdZct5iMInwYEGe/eR++1AA=="],
+
+    "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
+
+    "totalist": ["totalist@3.0.1", "", {}, "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ=="],
+
+    "ts-api-utils": ["ts-api-utils@2.1.0", "", { "peerDependencies": { "typescript": ">=4.8.4" } }, "sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ=="],
+
+    "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "typescript-eslint": ["typescript-eslint@8.46.2", "", { "dependencies": { "@typescript-eslint/eslint-plugin": "8.46.2", "@typescript-eslint/parser": "8.46.2", "@typescript-eslint/typescript-estree": "8.46.2", "@typescript-eslint/utils": "8.46.2" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-vbw8bOmiuYNdzzV3lsiWv6sRwjyuKJMQqWulBOU7M0RrxedXledX8G8kBbQeiOYDnTfiXz0Y4081E1QMNB6iQg=="],
+
+    "uint8arrays": ["uint8arrays@3.0.0", "", { "dependencies": { "multiformats": "^9.4.2" } }, "sha512-HRCx0q6O9Bfbp+HHSfQQKD7wU70+lydKVt4EghkdOvlK/NlrF90z+eXV34mUd48rNvVJXwkrMSPpCATkct8fJA=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
+
+    "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
+
+    "vite": ["vite@7.1.12", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-ZWyE8YXEXqJrrSLvYgrRP7p62OziLW7xI5HYGWFzOvupfAlrLvURSzv/FyGyy0eidogEM3ujU+kUG1zuHgb6Ug=="],
+
+    "vite-plugin-full-reload": ["vite-plugin-full-reload@1.2.0", "", { "dependencies": { "picocolors": "^1.0.0", "picomatch": "^2.3.1" } }, "sha512-kz18NW79x0IHbxRSHm0jttP4zoO9P9gXh+n6UTwlNKnviTTEpOlum6oS9SmecrTtSr+muHEn5TUuC75UovQzcA=="],
+
+    "vite-rs-plugin": ["vite-rs-plugin@1.0.1", "", { "dependencies": { "vite-plugin-full-reload": "^1.2.0" }, "peerDependencies": { "vite": "^5.0.0" }, "bin": { "cleanup": "bin/cleanForBuild.js" } }, "sha512-YhgflKQIRzuS5x66J3yICoVLH25D2fNU+jThK8tpYl/jGrXeIKT4w5VH1lkLPRC0SjK2ZCm9S6K9Z2ZFVDHjPQ=="],
+
+    "vitefu": ["vitefu@1.1.1", "", { "peerDependencies": { "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0" }, "optionalPeers": ["vite"] }, "sha512-B/Fegf3i8zh0yFbpzZ21amWzHmuNlLlmJT6n7bu5e+pCHUKQIfXSYokrqOBGEMMe9UG2sostKQF9mml/vYaWJQ=="],
+
+    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
+
+    "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
+
+    "yaml": ["yaml@1.10.2", "", {}, "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg=="],
+
+    "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
+
+    "zimmerframe": ["zimmerframe@1.1.4", "", {}, "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ=="],
+
+    "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
+
+    "@eslint/eslintrc/globals": ["globals@14.0.0", "", {}, "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ=="],
+
+    "@rollup/plugin-commonjs/is-reference": ["is-reference@1.2.1", "", { "dependencies": { "@types/estree": "*" } }, "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ=="],
+
+    "@typescript-eslint/eslint-plugin/ignore": ["ignore@7.0.5", "", {}, "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg=="],
+
+    "@typescript-eslint/typescript-estree/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="],
+
+    "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+
+    "micromatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="],
+
+    "vite-plugin-full-reload/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="],
+
+    "@typescript-eslint/typescript-estree/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="],
+  }
+}

web-ui/eslint.config.js

···
+import {fileURLToPath} from 'node:url';
+import {includeIgnoreFile} from '@eslint/compat';
+import js from '@eslint/js';
+import svelte from 'eslint-plugin-svelte';
+import {defineConfig} from 'eslint/config';
+import globals from 'globals';
+import ts from 'typescript-eslint';
+import svelteConfig from './svelte.config.js';
+
+const gitignorePath = fileURLToPath(new URL('./.gitignore', import.meta.url));
+
+export default defineConfig(
+    includeIgnoreFile(gitignorePath),
+    js.configs.recommended,
+    ...ts.configs.recommended,
+    ...svelte.configs.recommended,
+    {
+        languageOptions: {
+            globals: {...globals.browser, ...globals.node}
+        },
+        rules: { // typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects.
+            // see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors
+            'no-undef': 'off',
+            'quotes': ['error', 'single'],
+
+        }
+    },
+    {
+        files: [
+            '**/*.svelte',
+            '**/*.svelte.ts',
+            '**/*.svelte.js'
+        ],
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                extraFileExtensions: ['.svelte'],
+                parser: ts.parser,
+                svelteConfig
+            }
+        }
+    }
+);

web-ui/package-lock.json

···
+{
+  "name": "web-ui",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "web-ui",
+      "version": "0.0.1",
+      "dependencies": {
+        "@atcute/client": "^4.0.5",
+        "@atcute/lexicons": "^1.2.2",
+        "@pds-moover/lexicons": "^1.0.1",
+        "@pds-moover/moover": "^1.0.4"
+      },
+      "devDependencies": {
+        "@eslint/compat": "^1.4.0",
+        "@eslint/js": "^9.36.0",
+        "@sveltejs/adapter-auto": "^6.1.0",
+        "@sveltejs/adapter-node": "^5.4.0",
+        "@sveltejs/kit": "^2.43.2",
+        "@sveltejs/vite-plugin-svelte": "^6.2.0",
+        "@types/node": "^22",
+        "eslint": "^9.36.0",
+        "eslint-plugin-svelte": "^3.12.4",
+        "globals": "^16.4.0",
+        "svelte": "^5.39.5",
+        "svelte-check": "^4.3.2",
+        "typescript": "^5.9.2",
+        "typescript-eslint": "^8.44.1",
+        "vite": "^7.1.7"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-linux-x64-musl": "^4.52.5"
+      }
+    },
+    "../lexicon_types": {
+      "name": "@pds-moover/lexicon_types",
+      "version": "0.0.0",
+      "extraneous": true,
+      "dependencies": {
+        "@atproto/lexicon": "^0.5.1",
+        "@atproto/xrpc": "^0.7.5",
+        "cid": "multiformats/cid"
+      },
+      "devDependencies": {
+        "@atcute/lex-cli": "^2.2.2",
+        "@types/node": "^24.7.2",
+        "typescript": "~5.9.3",
+        "vite": "^7.1.7",
+        "vite-plugin-dts": "^4.5.4"
+      }
+    },
+    "../packages/lexicon_types": {
+      "name": "@pds-moover/lexicon_types",
+      "version": "0.0.0",
+      "extraneous": true,
+      "dependencies": {
+        "@atproto/lexicon": "^0.5.1",
+        "@atproto/xrpc": "^0.7.5",
+        "cid": "multiformats/cid"
+      },
+      "devDependencies": {
+        "@atcute/lex-cli": "^2.2.2"
+      }
+    },
+    "../packages/moover": {
+      "name": "@pds-moover/moover",
+      "version": "1.0.4",
+      "license": "MIT",
+      "dependencies": {
+        "@atcute/cbor": "^2.2.7",
+        "@atcute/client": "^4.0.4",
+        "@atcute/crypto": "^2.2.5",
+        "@atcute/did-plc": "^0.1.7",
+        "@atcute/identity-resolver": "^1.1.3",
+        "@atcute/lexicons": "^1.2.2",
+        "@atcute/multibase": "^1.1.6",
+        "@atproto/api": "^0.16.7",
+        "@pds-moover/lexicons": "^1.0.0",
+        "alpinejs": "^3.15.0",
+        "vite-plugin-full-reload": "^1.2.0",
+        "vite-rs-plugin": "1.0.1"
+      },
+      "devDependencies": {
+        "eslint": "^9.34.0",
+        "eslint-plugin-import": "^2.32.0",
+        "vite": "^7.1.7"
+      }
+    },
+    "../packages/moover/types": {
+      "extraneous": true
+    },
+    "node_modules/@atcute/client": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/@atcute/client/-/client-4.0.5.tgz",
+      "integrity": "sha512-R8Qen8goGmEkynYGg2m6XFlVmz0GTDvQ+9w+4QqOob+XMk8/WDpF4aImev7WKEde/rV2gjcqW7zM8E6W9NShDA==",
+      "license": "0BSD",
+      "dependencies": {
+        "@atcute/identity": "^1.1.1",
+        "@atcute/lexicons": "^1.2.2"
+      }
+    },
+    "node_modules/@atcute/identity": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@atcute/identity/-/identity-1.1.1.tgz",
+      "integrity": "sha512-zax42n693VEhnC+5tndvO2KLDTMkHOz8UExwmklvJv7R9VujfEwiSWhcv6Jgwb3ellaG8wjiQ1lMOIjLLvwh0Q==",
+      "license": "0BSD",
+      "dependencies": {
+        "@atcute/lexicons": "^1.2.2",
+        "@badrap/valita": "^0.4.6"
+      }
+    },
+    "node_modules/@atcute/lexicons": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/@atcute/lexicons/-/lexicons-1.2.2.tgz",
+      "integrity": "sha512-bgEhJq5Z70/0TbK5sx+tAkrR8FsCODNiL2gUEvS5PuJfPxmFmRYNWaMGehxSPaXWpU2+Oa9ckceHiYbrItDTkA==",
+      "license": "0BSD",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "esm-env": "^1.2.2"
+      }
+    },
+    "node_modules/@atproto/common-web": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@atproto/common-web/-/common-web-0.4.3.tgz",
+      "integrity": "sha512-nRDINmSe4VycJzPo6fP/hEltBcULFxt9Kw7fQk6405FyAWZiTluYHlXOnU7GkQfeUK44OENG1qFTBcmCJ7e8pg==",
+      "license": "MIT",
+      "dependencies": {
+        "graphemer": "^1.4.0",
+        "multiformats": "^9.9.0",
+        "uint8arrays": "3.0.0",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@atproto/lexicon": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/@atproto/lexicon/-/lexicon-0.5.1.tgz",
+      "integrity": "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A==",
+      "license": "MIT",
+      "dependencies": {
+        "@atproto/common-web": "^0.4.3",
+        "@atproto/syntax": "^0.4.1",
+        "iso-datestring-validator": "^2.2.2",
+        "multiformats": "^9.9.0",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@atproto/syntax": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@atproto/syntax/-/syntax-0.4.1.tgz",
+      "integrity": "sha512-CJdImtLAiFO+0z3BWTtxwk6aY5w4t8orHTMVJgkf++QRJWTxPbIFko/0hrkADB7n2EruDxDSeAgfUGehpH6ngw==",
+      "license": "MIT"
+    },
+    "node_modules/@atproto/xrpc": {
+      "version": "0.7.5",
+      "resolved": "https://registry.npmjs.org/@atproto/xrpc/-/xrpc-0.7.5.tgz",
+      "integrity": "sha512-MUYNn5d2hv8yVegRL0ccHvTHAVj5JSnW07bkbiaz96UH45lvYNRVwt44z+yYVnb0/mvBzyD3/ZQ55TRGt7fHkA==",
+      "license": "MIT",
+      "dependencies": {
+        "@atproto/lexicon": "^0.5.1",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@badrap/valita": {
+      "version": "0.4.6",
+      "resolved": "https://registry.npmjs.org/@badrap/valita/-/valita-0.4.6.tgz",
+      "integrity": "sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.11",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/compat": {
+      "version": "1.4.0",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.16.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "peerDependencies": {
+        "eslint": "^8.40 || 9"
+      },
+      "peerDependenciesMeta": {
+        "eslint": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.1",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.4.1",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.16.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.16.0",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.0",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.38.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.0",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.16.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.7",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@pds-moover/lexicons": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@pds-moover/lexicons/-/lexicons-1.0.1.tgz",
+      "integrity": "sha512-fv5b/DtHM7FEo/JklyF9gdK0ainlb6mWjWrBe6cmSAeg9G/4O2jBlQUOqfOAICY9gOcrCpkOrk9PHgGw//JQ2A==",
+      "license": "MIT",
+      "dependencies": {
+        "@atproto/lexicon": "^0.5.1",
+        "@atproto/xrpc": "^0.7.5"
+      }
+    },
+    "node_modules/@pds-moover/moover": {
+      "resolved": "../packages/moover",
+      "link": true
+    },
+    "node_modules/@polka/url": {
+      "version": "1.0.0-next.29",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/plugin-commonjs": {
+      "version": "28.0.9",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "commondir": "^1.0.1",
+        "estree-walker": "^2.0.2",
+        "fdir": "^6.2.0",
+        "is-reference": "1.2.1",
+        "magic-string": "^0.30.3",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=16.0.0 || 14 >= 14.17"
+      },
+      "peerDependencies": {
+        "rollup": "^2.68.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-commonjs/node_modules/is-reference": {
+      "version": "1.2.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*"
+      }
+    },
+    "node_modules/@rollup/plugin-json": {
+      "version": "6.1.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-node-resolve": {
+      "version": "16.0.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "@types/resolve": "1.20.2",
+        "deepmerge": "^4.2.2",
+        "is-module": "^1.0.0",
+        "resolve": "^1.22.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.78.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.3.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.52.5",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.5.tgz",
+      "integrity": "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.0.0",
+      "license": "MIT"
+    },
+    "node_modules/@sveltejs/acorn-typescript": {
+      "version": "1.0.6",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^8.9.0"
+      }
+    },
+    "node_modules/@sveltejs/adapter-auto": {
+      "version": "6.1.1",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@sveltejs/kit": "^2.0.0"
+      }
+    },
+    "node_modules/@sveltejs/adapter-node": {
+      "version": "5.4.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/plugin-commonjs": "^28.0.1",
+        "@rollup/plugin-json": "^6.1.0",
+        "@rollup/plugin-node-resolve": "^16.0.0",
+        "rollup": "^4.9.5"
+      },
+      "peerDependencies": {
+        "@sveltejs/kit": "^2.4.0"
+      }
+    },
+    "node_modules/@sveltejs/kit": {
+      "version": "2.48.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "@sveltejs/acorn-typescript": "^1.0.5",
+        "@types/cookie": "^0.6.0",
+        "acorn": "^8.14.1",
+        "cookie": "^0.6.0",
+        "devalue": "^5.3.2",
+        "esm-env": "^1.2.2",
+        "kleur": "^4.1.5",
+        "magic-string": "^0.30.5",
+        "mrmime": "^2.0.0",
+        "sade": "^1.8.1",
+        "set-cookie-parser": "^2.6.0",
+        "sirv": "^3.0.0"
+      },
+      "bin": {
+        "svelte-kit": "svelte-kit.js"
+      },
+      "engines": {
+        "node": ">=18.13"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.0.0",
+        "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0 || ^6.0.0-next.0",
+        "svelte": "^4.0.0 || ^5.0.0-next.0",
+        "vite": "^5.0.3 || ^6.0.0 || ^7.0.0-beta.0"
+      },
+      "peerDependenciesMeta": {
+        "@opentelemetry/api": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@sveltejs/vite-plugin-svelte": {
+      "version": "6.2.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sveltejs/vite-plugin-svelte-inspector": "^5.0.0",
+        "debug": "^4.4.1",
+        "deepmerge": "^4.3.1",
+        "magic-string": "^0.30.17",
+        "vitefu": "^1.1.1"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24"
+      },
+      "peerDependencies": {
+        "svelte": "^5.0.0",
+        "vite": "^6.3.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@sveltejs/vite-plugin-svelte-inspector": {
+      "version": "5.0.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.1"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24"
+      },
+      "peerDependencies": {
+        "@sveltejs/vite-plugin-svelte": "^6.0.0-next.0",
+        "svelte": "^5.0.0",
+        "vite": "^6.3.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@types/cookie": {
+      "version": "0.6.0",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "22.18.12",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/resolve": {
+      "version": "1.20.2",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.10.0",
+        "@typescript-eslint/scope-manager": "8.46.2",
+        "@typescript-eslint/type-utils": "8.46.2",
+        "@typescript-eslint/utils": "8.46.2",
+        "@typescript-eslint/visitor-keys": "8.46.2",
+        "graphemer": "^1.4.0",
+        "ignore": "^7.0.0",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^2.1.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^8.46.2",
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.5",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/@typescript-eslint/parser": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "8.46.2",
+        "@typescript-eslint/types": "8.46.2",
+        "@typescript-eslint/typescript-estree": "8.46.2",
+        "@typescript-eslint/visitor-keys": "8.46.2",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/project-service": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/tsconfig-utils": "^8.46.2",
+        "@typescript-eslint/types": "^8.46.2",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/scope-manager": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.46.2",
+        "@typescript-eslint/visitor-keys": "8.46.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/tsconfig-utils": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/type-utils": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.46.2",
+        "@typescript-eslint/typescript-estree": "8.46.2",
+        "@typescript-eslint/utils": "8.46.2",
+        "debug": "^4.3.4",
+        "ts-api-utils": "^2.1.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/types": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/project-service": "8.46.2",
+        "@typescript-eslint/tsconfig-utils": "8.46.2",
+        "@typescript-eslint/types": "8.46.2",
+        "@typescript-eslint/visitor-keys": "8.46.2",
+        "debug": "^4.3.4",
+        "fast-glob": "^3.3.2",
+        "is-glob": "^4.0.3",
+        "minimatch": "^9.0.4",
+        "semver": "^7.6.0",
+        "ts-api-utils": "^2.1.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
+      "version": "9.0.5",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch/node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/utils": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.7.0",
+        "@typescript-eslint/scope-manager": "8.46.2",
+        "@typescript-eslint/types": "8.46.2",
+        "@typescript-eslint/typescript-estree": "8.46.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.46.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.2",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/axobject-query": {
+      "version": "4.1.0",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "4.0.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/commondir": {
+      "version": "1.0.1",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cookie": {
+      "version": "0.6.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/cssesc": {
+      "version": "3.0.0",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "cssesc": "bin/cssesc"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/devalue": {
+      "version": "5.4.2",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.11",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.11",
+        "@esbuild/android-arm": "0.25.11",
+        "@esbuild/android-arm64": "0.25.11",
+        "@esbuild/android-x64": "0.25.11",
+        "@esbuild/darwin-arm64": "0.25.11",
+        "@esbuild/darwin-x64": "0.25.11",
+        "@esbuild/freebsd-arm64": "0.25.11",
+        "@esbuild/freebsd-x64": "0.25.11",
+        "@esbuild/linux-arm": "0.25.11",
+        "@esbuild/linux-arm64": "0.25.11",
+        "@esbuild/linux-ia32": "0.25.11",
+        "@esbuild/linux-loong64": "0.25.11",
+        "@esbuild/linux-mips64el": "0.25.11",
+        "@esbuild/linux-ppc64": "0.25.11",
+        "@esbuild/linux-riscv64": "0.25.11",
+        "@esbuild/linux-s390x": "0.25.11",
+        "@esbuild/linux-x64": "0.25.11",
+        "@esbuild/netbsd-arm64": "0.25.11",
+        "@esbuild/netbsd-x64": "0.25.11",
+        "@esbuild/openbsd-arm64": "0.25.11",
+        "@esbuild/openbsd-x64": "0.25.11",
+        "@esbuild/openharmony-arm64": "0.25.11",
+        "@esbuild/sunos-x64": "0.25.11",
+        "@esbuild/win32-arm64": "0.25.11",
+        "@esbuild/win32-ia32": "0.25.11",
+        "@esbuild/win32-x64": "0.25.11"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.38.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.1",
+        "@eslint/config-helpers": "^0.4.1",
+        "@eslint/core": "^0.16.0",
+        "@eslint/eslintrc": "^3.3.1",
+        "@eslint/js": "9.38.0",
+        "@eslint/plugin-kit": "^0.4.0",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-plugin-svelte": {
+      "version": "3.12.5",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.6.1",
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "esutils": "^2.0.3",
+        "globals": "^16.0.0",
+        "known-css-properties": "^0.37.0",
+        "postcss": "^8.4.49",
+        "postcss-load-config": "^3.1.4",
+        "postcss-safe-parser": "^7.0.0",
+        "semver": "^7.6.3",
+        "svelte-eslint-parser": "^1.4.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ota-meshi"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.1 || ^9.0.0",
+        "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "svelte": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esm-env": {
+      "version": "1.2.2",
+      "license": "MIT"
+    },
+    "node_modules/espree": {
+      "version": "10.4.0",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.6.0",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrap": {
+      "version": "2.1.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.4.15"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-glob": {
+      "version": "3.3.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
+      },
+      "engines": {
+        "node": ">=8.6.0"
+      }
+    },
+    "node_modules/fast-glob/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fastq": {
+      "version": "1.19.1",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.3.3",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "16.4.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/graphemer": {
+      "version": "1.4.0",
+      "license": "MIT"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-module": {
+      "version": "1.0.0",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-reference": {
+      "version": "3.0.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.6"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/iso-datestring-validator": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/iso-datestring-validator/-/iso-datestring-validator-2.2.2.tgz",
+      "integrity": "sha512-yLEMkBbLZTlVQqOnQ4FiMujR6T4DEcCb1xizmvXS+OxuhwcbtynoosRzdMA69zZCShCNAbi+gJ71FxZBBXx1SA==",
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/kleur": {
+      "version": "4.1.5",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/known-css-properties": {
+      "version": "0.37.0",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/lilconfig": {
+      "version": "2.1.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/locate-character": {
+      "version": "3.0.0",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/merge2": {
+      "version": "1.4.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/micromatch/node_modules/picomatch": {
+      "version": "2.3.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/mri": {
+      "version": "1.2.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mrmime": {
+      "version": "2.0.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/multiformats": {
+      "version": "9.9.0",
+      "resolved": "https://registry.npmjs.org/multiformats/-/multiformats-9.9.0.tgz",
+      "integrity": "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==",
+      "license": "(Apache-2.0 AND MIT)"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/postcss-load-config": {
+      "version": "3.1.4",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lilconfig": "^2.0.5",
+        "yaml": "^1.10.2"
+      },
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/postcss/"
+      },
+      "peerDependencies": {
+        "postcss": ">=8.0.9",
+        "ts-node": ">=9.0.0"
+      },
+      "peerDependenciesMeta": {
+        "postcss": {
+          "optional": true
+        },
+        "ts-node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/postcss-load-config/node_modules/yaml": {
+      "version": "1.10.2",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz",
+      "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/postcss-safe-parser": {
+      "version": "7.0.1",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss-safe-parser"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.31"
+      }
+    },
+    "node_modules/postcss-scss": {
+      "version": "4.0.9",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss-scss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.29"
+      }
+    },
+    "node_modules/postcss-selector-parser": {
+      "version": "7.1.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.11",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/reusify": {
+      "version": "1.1.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.52.5",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.52.5",
+        "@rollup/rollup-android-arm64": "4.52.5",
+        "@rollup/rollup-darwin-arm64": "4.52.5",
+        "@rollup/rollup-darwin-x64": "4.52.5",
+        "@rollup/rollup-freebsd-arm64": "4.52.5",
+        "@rollup/rollup-freebsd-x64": "4.52.5",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.52.5",
+        "@rollup/rollup-linux-arm-musleabihf": "4.52.5",
+        "@rollup/rollup-linux-arm64-gnu": "4.52.5",
+        "@rollup/rollup-linux-arm64-musl": "4.52.5",
+        "@rollup/rollup-linux-loong64-gnu": "4.52.5",
+        "@rollup/rollup-linux-ppc64-gnu": "4.52.5",
+        "@rollup/rollup-linux-riscv64-gnu": "4.52.5",
+        "@rollup/rollup-linux-riscv64-musl": "4.52.5",
+        "@rollup/rollup-linux-s390x-gnu": "4.52.5",
+        "@rollup/rollup-linux-x64-gnu": "4.52.5",
+        "@rollup/rollup-linux-x64-musl": "4.52.5",
+        "@rollup/rollup-openharmony-arm64": "4.52.5",
+        "@rollup/rollup-win32-arm64-msvc": "4.52.5",
+        "@rollup/rollup-win32-ia32-msvc": "4.52.5",
+        "@rollup/rollup-win32-x64-gnu": "4.52.5",
+        "@rollup/rollup-win32-x64-msvc": "4.52.5",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
+    "node_modules/sade": {
+      "version": "1.8.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mri": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.7.3",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/set-cookie-parser": {
+      "version": "2.7.1",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/sirv": {
+      "version": "3.0.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@polka/url": "^1.0.0-next.24",
+        "mrmime": "^2.0.0",
+        "totalist": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/svelte": {
+      "version": "5.42.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.4",
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@sveltejs/acorn-typescript": "^1.0.5",
+        "@types/estree": "^1.0.5",
+        "acorn": "^8.12.1",
+        "aria-query": "^5.3.1",
+        "axobject-query": "^4.1.0",
+        "clsx": "^2.1.1",
+        "esm-env": "^1.2.1",
+        "esrap": "^2.1.0",
+        "is-reference": "^3.0.3",
+        "locate-character": "^3.0.0",
+        "magic-string": "^0.30.11",
+        "zimmerframe": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/svelte-check": {
+      "version": "4.3.3",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "chokidar": "^4.0.1",
+        "fdir": "^6.2.0",
+        "picocolors": "^1.0.0",
+        "sade": "^1.7.4"
+      },
+      "bin": {
+        "svelte-check": "bin/svelte-check"
+      },
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "peerDependencies": {
+        "svelte": "^4.0.0 || ^5.0.0-next.0",
+        "typescript": ">=5.0.0"
+      }
+    },
+    "node_modules/svelte-eslint-parser": {
+      "version": "1.4.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-scope": "^8.2.0",
+        "eslint-visitor-keys": "^4.0.0",
+        "espree": "^10.0.0",
+        "postcss": "^8.4.49",
+        "postcss-scss": "^4.0.9",
+        "postcss-selector-parser": "^7.0.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0",
+        "pnpm": "10.18.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ota-meshi"
+      },
+      "peerDependencies": {
+        "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "svelte": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/totalist": {
+      "version": "3.0.1",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/ts-api-utils": {
+      "version": "2.1.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.12"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4"
+      }
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/typescript-eslint": {
+      "version": "8.46.2",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/eslint-plugin": "8.46.2",
+        "@typescript-eslint/parser": "8.46.2",
+        "@typescript-eslint/typescript-estree": "8.46.2",
+        "@typescript-eslint/utils": "8.46.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0",
+        "typescript": ">=4.8.4 <6.0.0"
+      }
+    },
+    "node_modules/uint8arrays": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/uint8arrays/-/uint8arrays-3.0.0.tgz",
+      "integrity": "sha512-HRCx0q6O9Bfbp+HHSfQQKD7wU70+lydKVt4EghkdOvlK/NlrF90z+eXV34mUd48rNvVJXwkrMSPpCATkct8fJA==",
+      "license": "MIT",
+      "dependencies": {
+        "multiformats": "^9.4.2"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "7.1.12",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitefu": {
+      "version": "1.1.1",
+      "dev": true,
+      "license": "MIT",
+      "workspaces": [
+        "tests/deps/*",
+        "tests/projects/*",
+        "tests/projects/workspace/packages/*"
+      ],
+      "peerDependencies": {
+        "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0"
+      },
+      "peerDependenciesMeta": {
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/yaml": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.1.tgz",
+      "integrity": "sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "peer": true,
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      }
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zimmerframe": {
+      "version": "1.1.4",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

web-ui/package.json

···
+{
+  "name": "web-ui",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "preview": "vite preview",
+    "prepare": "svelte-kit sync || echo ''",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@atcute/client": "^4.0.5",
+    "@atcute/lexicons": "^1.2.2",
+    "@pds-moover/lexicons": "^1.0.1",
+    "@pds-moover/moover": "^1.0.4"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.4.0",
+    "@eslint/js": "^9.36.0",
+    "@sveltejs/adapter-auto": "^6.1.0",
+    "@sveltejs/adapter-node": "^5.4.0",
+    "@sveltejs/kit": "^2.43.2",
+    "@sveltejs/vite-plugin-svelte": "^6.2.0",
+    "@types/node": "^22",
+    "eslint": "^9.36.0",
+    "eslint-plugin-svelte": "^3.12.4",
+    "globals": "^16.4.0",
+    "svelte": "^5.39.5",
+    "svelte-check": "^4.3.2",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.44.1",
+    "vite": "^7.1.7"
+  },
+  "optionalDependencies": {
+    "@rollup/rollup-linux-x64-musl": "^4.52.5"
+  }
+}

web-ui/src/app.d.ts

···
+import {} from '@pds-moover/lexicons'
+
+// See https://svelte.dev/docs/kit/types#app.d.ts
+// for information about these interfaces
+declare global {
+    namespace App {
+        // interface Error {}
+        // interface Locals {}
+        // interface PageData {}
+        // interface PageState {}
+        // interface Platform {}
+    }
+}
+
+export {};

web-ui/src/app.html

···
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		%sveltekit.head%
+	</head>
+	<body data-sveltekit-preload-data="hover">
+		<div style="display: contents">%sveltekit.body%</div>
+	</body>
+</html>

web-ui/src/lib/assets/favicon.svg

···
+<svg xmlns="http://www.w3.org/2000/svg" width="107" height="128" viewBox="0 0 107 128"><title>svelte-logo</title><path d="M94.157 22.819c-10.4-14.885-30.94-19.297-45.792-9.835L22.282 29.608A29.92 29.92 0 0 0 8.764 49.65a31.5 31.5 0 0 0 3.108 20.231 30 30 0 0 0-4.477 11.183 31.9 31.9 0 0 0 5.448 24.116c10.402 14.887 30.942 19.297 45.791 9.835l26.083-16.624A29.92 29.92 0 0 0 98.235 78.35a31.53 31.53 0 0 0-3.105-20.232 30 30 0 0 0 4.474-11.182 31.88 31.88 0 0 0-5.447-24.116" style="fill:#ff3e00"/><path d="M45.817 106.582a20.72 20.72 0 0 1-22.237-8.243 19.17 19.17 0 0 1-3.277-14.503 18 18 0 0 1 .624-2.435l.49-1.498 1.337.981a33.6 33.6 0 0 0 10.203 5.098l.97.294-.09.968a5.85 5.85 0 0 0 1.052 3.878 6.24 6.24 0 0 0 6.695 2.485 5.8 5.8 0 0 0 1.603-.704L69.27 76.28a5.43 5.43 0 0 0 2.45-3.631 5.8 5.8 0 0 0-.987-4.371 6.24 6.24 0 0 0-6.698-2.487 5.7 5.7 0 0 0-1.6.704l-9.953 6.345a19 19 0 0 1-5.296 2.326 20.72 20.72 0 0 1-22.237-8.243 19.17 19.17 0 0 1-3.277-14.502 17.99 17.99 0 0 1 8.13-12.052l26.081-16.623a19 19 0 0 1 5.3-2.329 20.72 20.72 0 0 1 22.237 8.243 19.17 19.17 0 0 1 3.277 14.503 18 18 0 0 1-.624 2.435l-.49 1.498-1.337-.98a33.6 33.6 0 0 0-10.203-5.1l-.97-.294.09-.968a5.86 5.86 0 0 0-1.052-3.878 6.24 6.24 0 0 0-6.696-2.485 5.8 5.8 0 0 0-1.602.704L37.73 51.72a5.42 5.42 0 0 0-2.449 3.63 5.79 5.79 0 0 0 .986 4.372 6.24 6.24 0 0 0 6.698 2.486 5.8 5.8 0 0 0 1.602-.704l9.952-6.342a19 19 0 0 1 5.295-2.328 20.72 20.72 0 0 1 22.237 8.242 19.17 19.17 0 0 1 3.277 14.503 18 18 0 0 1-8.13 12.053l-26.081 16.622a19 19 0 0 1-5.3 2.328" style="fill:#fff"/></svg>

web-ui/src/lib/components/LoadingSpinner.svelte

···
+<script lang="ts">
+	let { size = 16, className = '' }: { size?: number; className?: string } = $props();
+</script>
+
+<svg
+	class="spinner {className}"
+	viewBox="0 0 24 24"
+	style="display: inline-block; width: {size}px; height: {size}px; margin-right: 8px;"
+>
+	<circle cx="12" cy="12" r="10" stroke="currentColor" stroke-width="3" fill="none" opacity="0.25" />
+	<path
+		d="M12 2 A10 10 0 0 1 22 12"
+		stroke="currentColor"
+		stroke-width="3"
+		fill="none"
+		stroke-linecap="round"
+	>
+		<animateTransform
+			attributeName="transform"
+			type="rotate"
+			from="0 12 12"
+			to="360 12 12"
+			dur="1s"
+			repeatCount="indefinite"
+		/>
+	</path>
+</svg>

web-ui/src/lib/components/MooHeader.svelte

···
+<script lang="ts">
+    import cowPicture from '$lib/assets/moo.webp'
+
+    let {title, customImg = null} = $props();
+
+</script>
+
+
+<div>
+    <h1>{ title }</h1>
+    <div class="cow-image">
+        {#if customImg === null }
+            <img src={cowPicture} alt="Cartoon milk cow"
+                 style="max-width: 100%; max-height: 100%; object-fit: contain;">
+        {:else}
+            {@render customImg()}
+        {/if}
+    </div>
+    <div class="made-by-blur">Made by <a href="https://bsky.app/profile/baileytownsend.dev">@baileytownsend.dev</a>
+    </div>
+    <div class="support-buttons">
+        <span class="kofi-slot">
+            <a href='https://ko-fi.com/T6T61FYPX' target='_blank'><img height='36' style='border:0px;height:36px;'
+                                                                       src='https://storage.ko-fi.com/cdn/kofi1.png?v=6'
+                                                                       border='0'
+                                                                       alt='Buy Me a Coffee at ko-fi.com'/></a>
+        </span>
+        <iframe src="https://github.com/sponsors/fatfingers23/button" title="Sponsor fatfingers23" height="32"
+                width="114" style="border: 0; border-radius: 6px;"></iframe>
+    </div>
+</div>

web-ui/src/lib/components/NavBar.svelte

···
+<script lang="ts">
+    import {page} from '$app/state';
+    import {resolve} from '$app/paths';
+
+    let open = $state(false);
+
+    let links = [
+        {text: 'Info', path: '/info'},
+        {text: 'Moover', path: '/moover'},
+        {text: 'Missing Blobs', path: '/missing-blobs'},
+        {text: 'Turn Off', path: '/turn-off'},
+        {text: 'Backups', path: '/backups'},
+        {text: 'Restore', path: '/restore'},
+        {text: 'Legal', path: '/terms'}
+    ];
+</script>
+
+<header class="navbar" role="banner">
+
+    <div class="navbar-inner">
+        <a class="brand" href={resolve('/')}>PDS MOOver</a>
+        <button class="navbar-toggle" onclick={() => open = !open} aria-controls="primary-navigation"
+                aria-label="Toggle navigation">
+
+            <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
+                 viewBox="0 0 24.9512 17.1997">
+                <g>
+                    <rect height="17.1997" opacity="0" width="24.9512" x="0" y="0"/>
+                    <path d="M8.1543 16.9678L23.5962 16.9678C24.1455 16.9678 24.5972 16.5405 24.5972 15.9912C24.5972 15.4297 24.1455 15.0024 23.5962 15.0024L8.1543 15.0024C7.59277 15.0024 7.16553 15.4297 7.16553 15.9912C7.16553 16.5405 7.59277 16.9678 8.1543 16.9678Z"
+                          fill="white" fill-opacity="0.85"/>
+                    <path d="M1.2085 17.1997L3.2959 17.1997C3.96729 17.1997 4.5166 16.6504 4.5166 15.9912C4.5166 15.3076 3.96729 14.7705 3.2959 14.7705L1.2085 14.7705C0.537109 14.7705 0 15.3076 0 15.9912C0 16.6504 0.537109 17.1997 1.2085 17.1997Z"
+                          fill="white" fill-opacity="0.85"/>
+                    <path d="M8.1543 9.59473L23.5962 9.59473C24.1455 9.59473 24.5972 9.15527 24.5972 8.60596C24.5972 8.05664 24.1455 7.62939 23.5962 7.62939L8.1543 7.62939C7.59277 7.62939 7.16553 8.05664 7.16553 8.60596C7.16553 9.15527 7.59277 9.59473 8.1543 9.59473Z"
+                          fill="white" fill-opacity="0.85"/>
+                    <path d="M1.2085 9.82666L3.2959 9.82666C3.96729 9.82666 4.5166 9.27734 4.5166 8.60596C4.5166 7.93457 3.96729 7.39746 3.2959 7.39746L1.2085 7.39746C0.537109 7.39746 0 7.93457 0 8.60596C0 9.27734 0.537109 9.82666 1.2085 9.82666Z"
+                          fill="white" fill-opacity="0.85"/>
+                    <path d="M8.1543 2.20947L23.5962 2.20947C24.1455 2.20947 24.5972 1.78223 24.5972 1.23291C24.5972 0.671387 24.1455 0.244141 23.5962 0.244141L8.1543 0.244141C7.59277 0.244141 7.16553 0.671387 7.16553 1.23291C7.16553 1.78223 7.59277 2.20947 8.1543 2.20947Z"
+                          fill="white" fill-opacity="0.85"/>
+                    <path d="M1.2085 2.44141L3.2959 2.44141C3.96729 2.44141 4.5166 1.89209 4.5166 1.23291C4.5166 0.549316 3.96729 0.012207 3.2959 0.012207L1.2085 0.012207C0.537109 0.012207 0 0.549316 0 1.23291C0 1.89209 0.537109 2.44141 1.2085 2.44141Z"
+                          fill="white" fill-opacity="0.85"/>
+                </g>
+            </svg>
+
+        </button>
+        <nav id="primary-navigation" class="nav-links {open ? 'open' : ''}" aria-label="Primary"
+        >
+            {#each links as link (link.path)}
+                <a href={resolve(link.path)} class={page.url.pathname === link.path ? 'active' : '' } onclick={() => open = false}>{link.text}</a>
+            {/each}
+        </nav>
+    </div>
+</header>

web-ui/src/lib/components/OgImage.svelte

···
+<script>
+    import cowPicture from '$lib/assets/halloween_moover.webp'
+</script>
+<meta property="og:image" content="{cowPicture}">

web-ui/src/lib/components/RotationKeyDisplay.svelte

···
+<script lang="ts">
+    import {handleAndPDSResolver} from '@pds-moover/moover'
+    import type {RotationKeyType} from '$lib/types';
+
+
+    let {handle, rotationKey}: {
+        handle: string,
+        rotationKey: RotationKeyType
+    } = $props();
+
+
+    const copyToClipboard = async (text: string) => {
+        try {
+            await navigator.clipboard.writeText(text);
+            alert('Copied to clipboard');
+        } catch (e) {
+            console.error(e);
+            alert('Failed to copy to clipboard');
+        }
+    }
+
+    const downloadNewRotationKey = async (rotationKey: RotationKeyType, handle: string) => {
+        if (!rotationKey) return;
+        //try and find the did to add to the file as well
+        let didText = '';
+        try {
+            let {usersDid} = await handleAndPDSResolver(handle);
+            didText = `DID: ${usersDid}\n`;
+        } catch (e) {
+            //sliently log. Rather the user have their rotation key than not. a did can always be found other ways if needed
+            console.error(e);
+        }
+        
+        const content = `You can use these to recover your account if it's ever necessary via https://pdsmoover.com/restore. The restore process will ask for the Private key\n\nKEEP IN A SECURE LOCATION\n\n${didText}PublicKey: ${rotationKey.publicKey}\nPrivateKey: ${rotationKey.privateKey}\n`;
+        const blob = new Blob([content], {type: 'text/plain'});
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+
+
+        a.download = `${handle}-rotation-key.txt`;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    }
+</script>
+
+
+<div class="section" style="margin-top: 16px; border: 2px solid #f39c12; padding: 16px;">
+    <h3 style="color: #d35400;">Important: Save Your New Rotation Key Now</h3>
+    <p style="color: #c0392b; font-weight: bold;">
+        Warning: This is the only time we will show you your private rotation key. Save it in a secure place.
+        If you lose it, you may not be able to recover your account in the event of a PDS failure or hijack.
+    </p>
+    <div class="form-group">
+        <span>New Rotation Key (Private - keep secret)</span>
+        <div style="display:flex; gap:8px; align-items:center;">
+            {#if rotationKey}
+                <code
+                        style="overflow-wrap:anywhere;">{rotationKey.privateKey}</code>
+            {/if}
+
+            <button type="button"
+                    onclick={async ()  => await copyToClipboard(rotationKey.privateKey)}>Copy
+            </button>
+        </div>
+    </div>
+    <div class="form-group">
+        <button type="button" onclick={async () => await downloadNewRotationKey(rotationKey, handle)}>Download
+            Key File
+        </button>
+    </div>
+</div>

web-ui/src/lib/index.ts

···
+// place files you want to import through the `$lib` alias in this folder.

web-ui/src/lib/types.ts

···
+type RotationKeyType =
+    { privateKey: string, publicKey: `did:key:${string}` }
+
+export type {RotationKeyType}

web-ui/src/lib/utils/displayUtils.ts

···
+function formatBytes(bytes: number | null) {
+    if (bytes == null) return '—';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let i = 0;
+    let v = Number(bytes);
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return v.toFixed(1) + ' ' + units[i];
+}
+
+function formatDate(value: string | undefined) {
+    if (!value) return '—';
+    try {
+        const d = new Date(value);
+        return d.toLocaleString();
+    } catch (_) {
+        return String(value);
+    }
+}
+
+export {formatBytes, formatDate};

web-ui/src/routes/+layout.svelte

···
+<script lang="ts">
+    import favicon from '$lib/assets/moo.webp';
+    import '$lib/assets/style.css'
+    import NavBar from '$lib/components/NavBar.svelte';
+
+    let {children} = $props();
+
+
+</script>
+
+<svelte:head>
+    <link rel="icon" href={favicon}/>
+</svelte:head>
+
+
+<NavBar/>
+
+<main class="page-content">
+    {@render children?.()}
+</main>

web-ui/src/routes/+page.svelte

···
+<script lang="ts">
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import type {PageProps} from '../../.svelte-kit/types/src/routes/$types';
+    import {formatDate, formatBytes} from '$lib/utils/displayUtils';
+    import {resolve} from '$app/paths';
+    import OgImage from '$lib/components/OgImage.svelte';
+
+    let {data}: PageProps = $props();
+    let repoSize = $derived(formatBytes(data.estimatedReposSizeOnDisk));
+    let blobSize = $derived(formatBytes(data.estimatedBlobsSizeOnDisk));
+    let lastBackedUp = $derived(formatDate(data.lastBackupAt))
+    let lastStatusUpdate = $derived(formatDate(data.statusLastUpdated))
+
+</script>
+
+<svelte:head>
+    <title>PDS MOOver</title>
+    <meta property="og:description" content="PDS MOOver – ATProto tools for PDS migrations and backups"/>
+    <OgImage/>
+</svelte:head>
+
+<div class="container">
+
+    <MooHeader title="PDS MOOver"/>
+    <section class="section" style="text-align:left">
+        <p>
+            PDS MOOver is a set of AT Protocol tools to help you
+            <a href={resolve('/moover')}>migrate to a new PDS</a>,
+            <a href="/missing-blobs">find your missing blobs</a>,
+            sign up for free automated <a href="/backups">backups</a>, and <a href="/restore">restore your account</a>
+            in the event you need to.
+        </p>
+        <ul>
+            <li><a href={resolve('/moover')}>Moover</a> – helps you migrate to a new PDS.</li>
+            <li><a href="/missing-blobs">Missing Blobs</a> – find any missing blobs (pictures/videos) from a previous
+                migration.
+            </li>
+            <li><a href="/backups">Backups</a> – sign up for free automated backups stored on PDS MOOver servers and
+                view your account's backup status.
+            </li>
+            <li><a href="/restore">Restore</a> – restore from your backups if needed.</li>
+            <li><a href="/turn-off">Turn Off</a> – helper to make sure your old account is deactivated.</li>
+            <li><a href={resolve('/info')}>Info</a> – FAQs and a few other bits of information about our tools.</li>
+            <li><a href="https://tangled.org/@baileytownsend.dev/pds-moover">Check our source code on tangled</a></li>
+        </ul>
+    </section>
+
+    <section class="section" aria-labelledby="stats-heading">
+        <h2 id="stats-heading">Server stats</h2>
+        <span>Total stats for all accounts backed up on pdsmoover.com</span>
+        <div style="padding-top: 5%" class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-label">Total repositories</div>
+                <div class="stat-value">{data.totalRepos.toLocaleString()}</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-label">Total blobs</div>
+                <div class="stat-value">{data.totalBlobs.toLocaleString()}</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-label">Estimated total repo size</div>
+                <div class="stat-value">{repoSize}</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-label">Estimated total blob size</div>
+                <div class="stat-value">{blobSize}</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-label">Last backup ran at</div>
+                <div class="stat-value stat-value--small">{lastBackedUp}</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-label">Server Status last updated</div>
+                <div class="stat-value stat-value--small">{lastStatusUpdate}</div>
+            </div>
+        </div>
+        <!--        <div class="warning-message" x-show="error" x-text="error"></div>-->
+    </section>
+</div>

web-ui/src/routes/+page.ts

···
+import {Client, ok, simpleFetchHandler} from '@atcute/client';
+import {ComPdsmooverBackupDescribeServer} from '@pds-moover/lexicons';
+import type {PageLoad} from './$types';
+import {PUBLIC_XRPC_BASE} from '$env/static/public';
+import type {InferXRPCBodyOutput} from '@atcute/lexicons';
+
+export const load: PageLoad = async () => {
+    const handler = simpleFetchHandler({service: `https://${PUBLIC_XRPC_BASE}`});
+    const rpc = new Client({handler});
+    return await ok(
+        //@ts-expect-error: says it's not assignable to never
+        rpc.get('com.pdsmoover.backup.describeServer'),
+    ) as InferXRPCBodyOutput<ComPdsmooverBackupDescribeServer.mainSchema['output']>
+
+};

web-ui/src/routes/backups/+page.svelte

···
+<script lang="ts">
+    import {BackupService, PlcOps} from '@pds-moover/moover';
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import SignUpForm from './SignUpForm.svelte';
+    import RepoStatus from './RepoStatus.svelte';
+    import LoadingSpinner from '$lib/components/LoadingSpinner.svelte';
+    import type {InferXRPCBodyOutput} from '@atcute/lexicons';
+    import {ComPdsmooverBackupGetRepoStatus} from '@pds-moover/lexicons';
+    import {PUBLIC_XRPC_BASE} from '$env/static/public';
+
+
+    // Service instances
+    let backupService = $state(new BackupService(`did:web:${PUBLIC_XRPC_BASE}`));
+    let plcOps = $state(new PlcOps());
+
+    // State variables
+    let handle = $state('');
+    let password = $state('');
+    let twoFactorCode = $state('');
+    let showTwoFactorCodeInput = $state(false);
+    let errorMessage = $state<string | null>(null);
+    let showStatusMessage = $state(false);
+    let showLoginScreen = $state(true);
+    let showRepoNotFoundScreen = $state(false);
+    let repoStatus = $state<null | InferXRPCBodyOutput<
+        ComPdsmooverBackupGetRepoStatus.mainSchema['output']
+    >>(null);
+    let statusMessageText = $state('');
+    let isLoggingIn = $state(false);
+
+    function updateStatusHandler(status: string) {
+        console.log('Status update:', status);
+        statusMessageText = status;
+    }
+
+    async function handleLoginSubmit() {
+        errorMessage = null;
+        showStatusMessage = false;
+        isLoggingIn = true;
+
+        try {
+            if (showTwoFactorCodeInput && !twoFactorCode) {
+                errorMessage = 'Please enter the 2FA that was sent to your email.';
+                isLoggingIn = false;
+                return;
+            }
+            statusMessageText = 'Logging in...';
+            showStatusMessage = true;
+            const result = await backupService.loginAndStatus(
+                handle,
+                password,
+                updateStatusHandler,
+                twoFactorCode
+            );
+            if (result === null) {
+                showRepoNotFoundScreen = true;
+                showLoginScreen = false;
+                showStatusMessage = false;
+            } else {
+                repoStatus = result;
+                showLoginScreen = false;
+                showStatusMessage = false;
+            }
+        } catch (e) {
+            console.error(e);
+            showStatusMessage = false;
+            //@ts-expect-error: Error is handled
+            if (e.error === 'AuthFactorTokenRequired') {
+                showTwoFactorCodeInput = true;
+                errorMessage = 'Two-factor code required. Check your email and enter the code.';
+            } else {
+                //@ts-expect-error: Error is handled
+                errorMessage = e.message || 'An unexpected error occurred.';
+            }
+        } finally {
+            isLoggingIn = false;
+        }
+    }
+
+    function handleSignUpComplete(
+        status: InferXRPCBodyOutput<ComPdsmooverBackupGetRepoStatus.mainSchema['output']>
+    ) {
+        repoStatus = status;
+        showRepoNotFoundScreen = false;
+        showLoginScreen = false;
+    }
+</script>
+
+<svelte:head>
+    <title>PDS MOOver - Backups</title>
+    <meta property="og:description" content="PDS MOOver backups"/>
+    <meta property="og:image" content="/halloween_moover.webp"/>
+</svelte:head>
+
+<div class="container">
+    <MooHeader title="Backups"/>
+
+    <!-- Login Screen -->
+    {#if showLoginScreen}
+        <div class="section" style="text-align: left;">
+            <p>
+                PDS MOOver can provide worry-free backups of your AT Protocol account. This is a free
+                service for individual accounts and stores the backups on PDS MOOver's servers. Just like
+                your <a
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    href="https://blueskyweb.zendesk.com/hc/en-us/articles/15835264007693-Data-Privacy"
+            >AT Proto data</a
+            >, this is also public. On login, you will be asked if you'd like to add a rotation key to
+                your account. A rotation key is a recovery key that allows you to restore your account if
+                your PDS ever goes down. If you're already signed up for backups, then you can log in here
+                to manage them.
+            </p>
+        </div>
+
+        <form
+                id="backup-signup-form"
+                onsubmit={(e) => {
+				e.preventDefault();
+				handleLoginSubmit();
+			}}
+        >
+            <div class="section">
+                <h2>Sign in to your account</h2>
+                <div class="form-group">
+                    <label for="handle">Handle</label>
+                    <input
+                            type="text"
+                            id="handle"
+                            name="handle"
+                            placeholder="alice.bsky.social"
+                            bind:value={handle}
+                            required
+                    />
+                </div>
+
+                <div class="form-group">
+                    <label for="password">Real Password</label>
+                    <input type="password" id="password" name="password" bind:value={password} required/>
+                    <p>
+                        If you are signing up and adding a rotation key you have to use your account's real
+                        password. If you are just managing your backups or have your own rotation key you can use
+                        an app password
+                    </p>
+                </div>
+
+                {#if showTwoFactorCodeInput}
+                    <div class="form-group">
+                        <label for="two-factor-code">Two-factor code (email)</label>
+                        <input
+                                type="text"
+                                id="two-factor-code"
+                                name="two-factor-code"
+                                bind:value={twoFactorCode}
+                        />
+                        <div class="error-message">Enter the 2FA code from your email.</div>
+                    </div>
+                {/if}
+            </div>
+
+            {#if errorMessage}
+                <div class="error-message">{errorMessage}</div>
+            {/if}
+            {#if showStatusMessage}
+                <div class="status-message">{statusMessageText}</div>
+            {/if}
+            <div>
+                <button type="submit" disabled={isLoggingIn}>
+                    {#if isLoggingIn}
+                        <LoadingSpinner/>
+                    {/if}
+                    Login for backups
+                </button>
+            </div>
+        </form>
+    {/if}
+
+    <!-- Sign Up Screen -->
+    {#if showRepoNotFoundScreen}
+        <SignUpForm {backupService} {plcOps} {handle} onComplete={handleSignUpComplete}/>
+    {/if}
+
+    <!-- Repo Status View -->
+    {#if repoStatus && !showLoginScreen && !showRepoNotFoundScreen}
+        <RepoStatus {backupService} bind:repoStatus/>
+    {/if}
+</div>

web-ui/src/routes/backups/RepoStatus.svelte

···
+<script lang="ts">
+    import type {BackupService} from '@pds-moover/moover';
+    import type {InferXRPCBodyOutput} from '@atcute/lexicons';
+    import {ComPdsmooverBackupGetRepoStatus} from '@pds-moover/lexicons';
+    import {formatDate, formatBytes} from '$lib/utils/displayUtils';
+    import LoadingSpinner from '$lib/components/LoadingSpinner.svelte';
+
+
+    let {
+        backupService,
+        repoStatus = $bindable()
+    }: {
+        backupService: BackupService;
+        repoStatus: InferXRPCBodyOutput<ComPdsmooverBackupGetRepoStatus.mainSchema['output']> | null;
+    } = $props();
+
+    // State variables
+    let errorMessage = $state<string | null>(null);
+    let showStatusMessage = $state(false);
+    let statusMessageText = $state('');
+    let isRefreshing = $state(false);
+    let isRunningBackup = $state(false);
+    let isDeleting = $state(false);
+
+    function updateStatusHandler(status: string) {
+        console.log('Status update:', status);
+        statusMessageText = status;
+    }
+
+    async function handleRunBackupNow() {
+        errorMessage = null;
+        isRunningBackup = true;
+        showStatusMessage = true;
+        try {
+            await backupService.runBackupNow(updateStatusHandler);
+            repoStatus = await backupService.getUsersRepoStatus(updateStatusHandler);
+            updateStatusHandler('Backup request sent. Status refreshed.');
+            showStatusMessage = false;
+        } catch (e) {
+            console.error(e);
+            //@ts-expect-error: Error is handled
+            errorMessage = e.message || 'Failed to request backup.';
+        } finally {
+            isRunningBackup = false;
+        }
+    }
+
+    async function handleRemoveRepo() {
+        if (
+            confirm(
+                'Deleting your backups removes all your data and unregisters you for automatic backups. Your rotation key created here will stay valid, but you will not be able to restore your data from PDS MOOver.'
+            )
+        ) {
+            isDeleting = true;
+            try {
+                await backupService.removeRepo(updateStatusHandler);
+                repoStatus = await backupService.getUsersRepoStatus(updateStatusHandler);
+            } catch (e) {
+                console.error(e);
+                //@ts-expect-error: Error is handled
+                errorMessage = e.message || 'Failed to delete backup repository';
+            } finally {
+                isDeleting = false;
+            }
+        }
+    }
+
+    async function refreshStatus() {
+        isRefreshing = true;
+        try {
+            repoStatus = await backupService.getUsersRepoStatus(updateStatusHandler);
+        } catch (e) {
+            console.error(e);
+            //@ts-expect-error: Error is handled
+            errorMessage = e.message || 'Failed to refresh status';
+        } finally {
+            showStatusMessage = false;
+            isRefreshing = false;
+        }
+    }
+</script>
+
+<div class="section">
+    <div class="section-header">
+        <h2 style="margin: 0;">Backup repository status</h2>
+        <button
+                type="button"
+                class="icon-button"
+                title="Refresh status"
+                aria-label="Refresh status"
+                onclick={refreshStatus}
+                disabled={isRefreshing}
+                style={isRefreshing ? 'opacity: 0.6;' : ''}
+        >
+            <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"
+                 style={isRefreshing ? 'animation: spin 1s linear infinite;' : ''}>
+                <path
+                        d="M17.65 6.35A7.95 7.95 0 0012 4a8 8 0 108 8h-2a6 6 0 11-6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"
+                ></path>
+            </svg>
+        </button>
+    </div>
+    <div class="stats-grid">
+        <div class="stat-card">
+            <div class="stat-label">DID</div>
+            <div class="stat-value stat-value--small">{repoStatus?.did || '—'}</div>
+        </div>
+        <div class="stat-card">
+            <div class="stat-label">Created</div>
+            <div class="stat-value stat-value--small">{formatDate(repoStatus?.createdAt)}</div>
+        </div>
+        {#if repoStatus?.lastBackup != null}
+            <div class="stat-card">
+                <div class="stat-label">Last backup</div>
+                <div class="stat-value stat-value--small">{formatDate(repoStatus.lastBackup)}</div>
+            </div>
+        {/if}
+        {#if repoStatus?.rev != null}
+            <div class="stat-card">
+                <div class="stat-label">Current rev</div>
+                <div class="stat-value stat-value--small">{repoStatus.rev}</div>
+            </div>
+        {/if}
+        {#if repoStatus?.blobCount != null}
+            <div class="stat-card">
+                <div class="stat-label">Total blobs</div>
+                <div class="stat-value">{repoStatus.blobCount.toLocaleString()}</div>
+            </div>
+        {/if}
+        {#if repoStatus?.estimatedBackupSize != null}
+            <div class="stat-card">
+                <div class="stat-label">Estimated size</div>
+                <div class="stat-value">{formatBytes(repoStatus.estimatedBackupSize)}</div>
+            </div>
+        {/if}
+        {#if repoStatus?.missingBlobCount != null}
+            <div class="stat-card">
+                <div class="stat-label">Missing blobs</div>
+                <div class="stat-value">{repoStatus.missingBlobCount.toLocaleString()}</div>
+            </div>
+        {/if}
+        {#if repoStatus?.source != null}
+            <div class="stat-card">
+                <div class="stat-label">Source</div>
+                <div class="stat-value stat-value--small">{repoStatus.source}</div>
+            </div>
+        {/if}
+    </div>
+    <div class="actions" style="padding-top: 5%">
+        <button type="button" onclick={handleRunBackupNow} disabled={isRunningBackup}>
+            {#if isRunningBackup}
+                <LoadingSpinner/>
+            {/if}
+            Manually run backup now
+        </button>
+        <button type="button" style="background-color: #c62828; color: #fff;" onclick={handleRemoveRepo}
+                disabled={isDeleting}>
+            {#if isDeleting}
+                <LoadingSpinner/>
+            {/if}
+            Delete Backups
+        </button>
+    </div>
+    {#if errorMessage}
+        <div class="error-message">{errorMessage}</div>
+    {/if}
+    {#if showStatusMessage}
+        <div class="status-message">{statusMessageText}</div>
+    {/if}
+</div>
+
+<style>
+    @keyframes spin {
+        from {
+            transform: rotate(0deg);
+        }
+        to {
+            transform: rotate(360deg);
+        }
+    }
+</style>

web-ui/src/routes/backups/SignUpForm.svelte

···
+<script lang="ts">
+    import type {BackupService, PlcOps} from '@pds-moover/moover';
+    import type {RotationKeyType} from '$lib/types';
+    import type {InferXRPCBodyOutput} from '@atcute/lexicons';
+    import {ComPdsmooverBackupGetRepoStatus} from '@pds-moover/lexicons';
+    import RotationKeyDisplay from '$lib/components/RotationKeyDisplay.svelte';
+    import LoadingSpinner from '$lib/components/LoadingSpinner.svelte';
+
+    let {
+        backupService,
+        plcOps,
+        handle,
+        onComplete
+    }: {
+        backupService: BackupService;
+        plcOps: PlcOps;
+        handle: string;
+        onComplete: (
+            repoStatus: InferXRPCBodyOutput<ComPdsmooverBackupGetRepoStatus.mainSchema['output']>
+        ) => void;
+    } = $props();
+
+    // State variables
+    let errorMessage = $state<string | null>(null);
+    let showStatusMessage = $state(false);
+    let statusMessageText = $state('');
+    let addRecoveryKey = $state(true);
+    let plcTokenInput = $state<string | null>(null);
+    let newlyCreatedRotationKey = $state<RotationKeyType | null>(null);
+    let showRotationKeyScreen = $state(false);
+    let isRequestingToken = $state(false);
+    let isSigningUp = $state(false);
+    let isProceeding = $state(false);
+
+    function updateStatusHandler(status: string) {
+        console.log('Status update:', status);
+        statusMessageText = status;
+    }
+
+    async function requestPlcToken() {
+        errorMessage = null;
+        isRequestingToken = true;
+        try {
+            showStatusMessage = true;
+            updateStatusHandler('Requesting PLC token…');
+            await backupService.requestAPlcToken();
+            updateStatusHandler('PLC token emailed. Check your inbox and paste the token below.');
+        } catch (e) {
+            //@ts-expect-error: Error is handled
+            errorMessage = e?.message || 'Failed to request PLC token';
+        } finally {
+            showStatusMessage = false;
+            isRequestingToken = false;
+        }
+    }
+
+    async function handleSignUpSubmit() {
+        errorMessage = null;
+        isSigningUp = true;
+        showStatusMessage = true;
+        try {
+            if (addRecoveryKey) {
+                if (!plcTokenInput) {
+                    errorMessage =
+                        'Please paste your PLC token. Use the "Email me a PLC token" button to request one.';
+                    showStatusMessage = false;
+                    isSigningUp = false;
+                    return;
+                }
+                updateStatusHandler('Creating new rotation key…');
+                const created = await plcOps.createANewSecp256k1();
+                newlyCreatedRotationKey = created;
+                updateStatusHandler('Adding new rotation key to your DID…');
+                await backupService.addANewRotationKey(plcTokenInput, created.publicKey);
+                updateStatusHandler('Rotation key added. Please save the private key now.');
+                showRotationKeyScreen = true;
+                showStatusMessage = false;
+                isSigningUp = false;
+                //Return and then on next button click we sign the user up that way if it fails it won't ruin them from
+                //Getting their rotation key
+                return;
+            }
+            await backupService.signUp(updateStatusHandler);
+            updateStatusHandler('Signed up for backups successfully.');
+
+            const repoStatus = await backupService.getUsersRepoStatus(updateStatusHandler);
+            showStatusMessage = false;
+            isSigningUp = false;
+            onComplete(repoStatus);
+        } catch (e) {
+            console.error(e);
+            //@ts-expect-error: Error is handled
+            errorMessage = e.message || 'Failed to sign up for backups.';
+            showStatusMessage = false;
+            isSigningUp = false;
+        }
+    }
+
+    async function proceedToRepoStatus() {
+        isProceeding = true;
+        try {
+            await backupService.signUp(updateStatusHandler);
+            updateStatusHandler('Signed up for backups successfully.');
+
+            showStatusMessage = true;
+            updateStatusHandler('Fetching repository status…');
+            const repoStatus = await backupService.getUsersRepoStatus(updateStatusHandler);
+            showRotationKeyScreen = false;
+            showStatusMessage = false;
+            isProceeding = false;
+            onComplete(repoStatus);
+        } catch (e) {
+            console.error(e);
+            //@ts-expect-error: Error is handled
+            errorMessage = e?.message || 'Failed to load repository status';
+            showStatusMessage = false;
+            isProceeding = false;
+        }
+    }
+</script>
+
+{#if showRotationKeyScreen && newlyCreatedRotationKey}
+    <div class="section">
+        <RotationKeyDisplay {handle} rotationKey={newlyCreatedRotationKey}/>
+        <div class="form-group">
+            <button type="button" onclick={proceedToRepoStatus} disabled={isProceeding}>
+                {#if isProceeding}
+                    <LoadingSpinner/>
+                {/if}
+                Next
+            </button>
+        </div>
+    </div>
+{:else}
+    <div class="section">
+        <h2>No backup repository found</h2>
+        <p style="text-align: left;">
+            Sign up now to backup your AT Protocol account. PDS MOOver automatically backups your posts,
+            likes, media, and all account data every 6 hours. This is stored on our servers in something
+            called an <a
+                target="_blank"
+                rel="noopener noreferrer"
+                href="https://en.wikipedia.org/wiki/Object_storage">object store.</a
+        >
+            Just like your
+            <a
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    href="https://blueskyweb.zendesk.com/hc/en-us/articles/15835264007693-Data-Privacy"
+            >AT Proto data</a
+            >, this data is public.
+        </p>
+        <div class="info">
+            <h3>Critical: Save your rotation key</h3>
+            <p style="text-align: left;">
+                A rotation key is your account recovery key. If you've migrated to a selfhosted or
+                thirdparty PDS, this key is the <span class="bold">ONLY</span> way to recover your account if
+                your PDS goes down. Without it, a failed or rogue PDS means permanent account loss. Generate
+                one and store it safely.
+            </p>
+        </div>
+        <div class="form-group">
+            <label style="display: inline-flex; align-items: center; gap: 0.5rem; white-space: nowrap;">
+                <input type="checkbox" bind:checked={addRecoveryKey} style="margin: 0;"/>
+                <span>Create a rotation key (recommended)</span>
+            </label>
+        </div>
+        {#if addRecoveryKey}
+            <div class="form-group">
+                <p>
+                    To add a new rotation key, you must authorize a PLC operation. Click the button to email
+                    yourself a PLC token, then paste it below.
+                    <span class="bold"
+                    >NOTE: Adding a new key will remove all current rotation keys except for the one created
+						and the one from your PDS</span
+                    >
+                </p>
+
+                <div class="actions" style="margin-bottom: 0.5rem;">
+                    <button type="button" onclick={requestPlcToken} disabled={isRequestingToken}>
+                        {#if isRequestingToken}
+                            <LoadingSpinner/>
+                        {/if}
+                        Email me a PLC token
+                    </button>
+                </div>
+                <div class="form-group">
+                    <label for="plc-token">PLC token</label>
+                    <input
+                            type="text"
+                            id="plc-token"
+                            name="plc-token"
+                            bind:value={plcTokenInput}
+                            placeholder="Paste PLC token from email"
+                            autocomplete="one-time-code"
+                    />
+                </div>
+            </div>
+        {:else}
+            <div class="form-group">
+                <div class="status-message" style="text-align: left;">
+                    <p>
+                        <span class="bold">Note:</span> a recovery key is
+                        <span class="bold">required</span> to restore your account. If you're not sure what this means,
+                        then it is important to check the above box and save the rotation key file given.
+                    </p>
+                </div>
+            </div>
+        {/if}
+        {#if errorMessage}
+            <div class="error-message">{errorMessage}</div>
+        {/if}
+        {#if showStatusMessage}
+            <div class="status-message">{statusMessageText}</div>
+        {/if}
+        <div>
+            <button type="button" onclick={handleSignUpSubmit} disabled={isSigningUp}>
+                {#if isSigningUp}
+                    <LoadingSpinner/>
+                {/if}
+                Sign up for backups
+            </button>
+        </div>
+    </div>
+{/if}

web-ui/src/routes/info/+page.svelte

···
+<script lang="ts">
+    import OgImage from '$lib/components/OgImage.svelte';
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import SignThePapersImg from '$lib/assets/sign_the_papers.png'
+</script>
+
+<svelte:head>
+    <title>PDS MOOver - Info</title>
+    <meta property="og:description" content="ATProto account migration tool"/>
+    <OgImage/>
+</svelte:head>
+
+<div class="container">
+    <MooHeader title="PDS MOOver Info"/>
+
+
+    <div class="section" id="top">
+        <p> This page is to help you decide if you want to use PDS MOOver to move your ATProto(Bluesky) account to a new
+            PDS along with some other information about all the new tools.
+            One way or the other. TLDR (You should still read the whole thing), at least read and follow the <a
+                    href="#precautions">precautions section</a>.</p>
+
+
+        <section class="section" style="text-align:left">
+            <h2>Info</h2>
+            <p>PDS MOOver is a set of tools to help you migrate to a new PDS. The creator
+                or host of this tool will not be able to help you recover your account if something goes wrong. So be
+                advised you and your PDS admin may be on your own besides helpful answers and understand the risk you
+                take in doing an account movement.</p>
+        </section>
+
+
+        <nav aria-label="Table of contents" class="section" style="text-align:left">
+            <h3>Table of contents</h3>
+            <ol>
+                <li><a href="#precautions">Precautions</a></li>
+                <li><a href="#backups">Backups</a></li>
+                <li><a href="#restore">Restore</a></li>
+                <li><a href="#blacksky">I'm here for Blacksky, is there a video guide?</a></li>
+                <li><a href="#cant-login">I can't log in?/Says my account is deactivated?</a></li>
+                <li><a href="#invalid-handle">My account says Invalid Handle?</a></li>
+                <li><a href="#help">!!!!!HELP!!!!!</a></li>
+                <li><a href="#why">Why doesn't PDS MOOver have xyz?</a></li>
+                <li><a href="#done">Alright account migrated, now what?</a></li>
+                <li><a href="#slow">Why is it so SLOW?</a></li>
+                <li><a href="#open-source">Can I check out the code anywhere?</a></li>
+            </ol>
+        </nav>
+
+        <section id="precautions" class="section" style="text-align:left">
+            <h2>Precautions</h2>
+            <p> Migrations can be a potentially dangerous operation. It is recommended to follow these few steps to
+                protect your account and identity.</p>
+            <ul>
+                <li>During migration make sure to do not leave the page</li>
+                <li>It is recommended to use a desktop computer for this process due to the amount of time it can
+                    take.
+                </li>
+                <li>Your account is not actually fully moved over to the new PDS till you receive a code in your email
+                    and enter it on PDS MOOver, this is the final step.
+                </li>
+                <li>Your data will not be deleted from Bluesky(or your previous PDS) during migration. If you find you
+                    are missing any pictures or videos after the move you can use the <a href="/missing">Missing
+                        tool</a> to recover those from your previous PDS.
+                </li>
+            </ul>
+
+            <p>At the end of your migration and before you move you will be asked if you'd like to sign up for PDS
+                MOOver's backup service and to add a rotation key. Both of these are recommended and secure your account
+                if your PDS ever goes down, allowing for account recovery. </p>
+            <img src="{SignThePapersImg}" alt="Sign the papers"
+                 style="max-width: 100%; max-height: 100%; object-fit: contain;">
+
+        </section>
+
+        <section id="backups" class="section" style="text-align:left">
+            <h2>Backups</h2>
+            <p>PDS MOOver now supports backups. These are automated backups of your account saving your repo
+                (posts,likes,etc), and your blobs(picture/videos) from your AT Proto account to a cloud base object
+                store (S3). This is a free service for individual accounts and stores the backups on PDS MOOver's
+                servers. These backups will happen every 6 hours from the time you sign up. We are expecting to lower
+                this as we see how the service does. On login, you will be asked if you'd like to add a rotation key to
+                your account. It is highly recommended to do this if you do not already have one. This is the only way
+                you can recover your account in the event of a PDS failure or rogue account takeover</p>
+
+            <p>Just like your <a target="_blank" rel="noopener noreferrer"
+                                 href="https://blueskyweb.zendesk.com/hc/en-us/articles/15835264007693-Data-Privacy">AT
+                Proto data</a>, your backedup data is also public.
+                You can access your data much the same way you do on your PDS by calling these endpoints. Since these
+                behave much the same as the PDS they are public.
+            </p>
+            <ul>
+                <li><code>/xrpc/com.atproto.sync.getRepo?did="your did"</code> to get a copy of your repo's CAR export
+                </li>
+                <li><code>/xrpc/com.atproto.sync.getBlob?did="your did"&cid="cid of the blob"</code></li>
+            </ul>
+
+        </section>
+
+        <section id="restore" class="section" style="text-align:left">
+            <h2>Restore</h2>
+            <p>Backups without a restore option aren't very good backups. So to pair well with our new backup service
+                PDS MOOver now also offers recovery of your account and restoring from a backup. To use this you must
+                have your Private Rotation Key. You can add one to your account either after migration or during backups
+                sign up. This recovery process follows much the same process as out line in <a
+                        href="https://www.da.vidbuchanan.co.uk/blog/adversarial-pds-migration.html">Adversarial ATProto
+                    PDS Migration</a> blog post by <a href="https://bsky.app/profile/retr0.id">@retr0.id</a>. </p>
+        </section>
+
+        <section id="blacksky" class="section" style="text-align:left">
+            <h2>I'm here for Blacksky, Is there a video guide?</h2>
+            <p>
+                <a href="https://blacksky.community/profile/did:plc:g7j6qok5us4hjqlwjxwrrkjm">@sharpiepls.com</a> has
+                made an amazing video guide on
+                how to use PDS MOOver to move your bluesky account to blacksky.app.
+                <video width="100%" controls>
+
+                    <source src="https://blacksky.app/xrpc/com.atproto.sync.getBlob?did=did:plc:g7j6qok5us4hjqlwjxwrrkjm&cid=bafkreielhdoa2lcyiat5oumkbkwy26hlj36rwwwfi5fbnvd5haxq3t4joa"/>
+                </video>
+            </p>
+        </section>
+
+        <section id="cant-login" class="section" style="text-align:left">
+            <h2>I can't log in?/Says my account is deactivated?</h2>
+            <p>When you move to a non Bluesky PDS you have to do an extra step on login.</p>
+            <ol>
+                <li>On the Sign in screen for <a href="https://bsky.app">bsky.app</a> or on the app click the top input
+                    titled "Hosting provider" and has a globe icon and says Bluesky Social"
+                </li>
+                <li>Click the tab labeled custom</li>
+                <li>In the input for server address you put the same URL you used for the new PDS URL with the https://
+                    like so <code>https://example.com</code></li>
+                <li>Click done and enter your new handle(or email) and password</li>
+            </ol>
+        </section>
+
+        <section id="invalid-handle" class="section" style="text-align:left">
+            <h2>My account says Invalid Handle?</h2>
+            <p>It's a bit of a bug sometimes. I'm not sure what causes it, but usually mentioning your handle in a post
+                or reply fixes it.
+                Like <code>@fullhandle.newpds.com</code>, may or may not highlight it blue and autofill it but make sure
+                you have the
+                full handle and the @ like that. Can also check your handle with the <a
+                        href="https://bsky-debug.app/handle">Bluesky Debug Page</a>. If you see green, and it says one
+                of
+                them pass you should be fine and just may take a while to update.</p>
+        </section>
+
+        <section id="help" class="section" style="text-align:left">
+            <h2>!!!!!HELP!!!!!</h2>
+            <p>If you're having issues with PDS MOOver first of all, I'm very sorry. I have tested this to the best of
+                my
+                ability, but PDS migrations do come with risks. I would recommend getting with the owner of the PDS and
+                seeing where the account stands with tools like <a href="https://pdsls.dev">pdsls</a>.</p>
+
+            <p> The tool is designed to be able to be re ran IF you set the Advance Options flags.For example, lets say
+                if it created the account, repo is there but some blobs are missing. You can uncheck everything but
+                "Migrate Missing Blobs", "Migrate Prefs", and "Migrate PLC record" and it will pick up after the account
+                repo migration. It is odd in the fact that all the fields are required. That's just to cut down on logic
+                to hopefully cut down on bugs. If you don't ever see the "Please enter your PLC Token" and enter the
+                token sent to your email, you can just
+                forget about it and call it a day if it's too much. Your old account is still active and working.</p>
+        </section>
+
+
+        <section id="why" class="section" style="text-align:left">
+            <h2>Why doesn't PDS MOOver have xyz for migrations?</h2>
+            <p>PDS MOOver was designed to pretty much be the goat account migration with a UI. Like in this <a
+                    href="https://whtwnd.com/bnewbold.net/3l5ii332pf32u"> post</a>. Keeping it simple and hard fails if
+                anything
+                goes wrong
+                to
+                hopefully cover most use cases.</p>
+        </section>
+
+        <section id="done" class="section" style="text-align:left">
+            <h2>Alright account migrated, now what?</h2>
+            <p>Welcome to your new PDS! You can login to your new PDS on Bluesky's login screen by selecting "Hosting
+                provider" and entering your PDS url. I also recommend making sure you are signed up for our <a
+                        href="/backups">backups</a> and have a recovery key that you control in case your PDS disappears
+                overnight you can regain your account. </p>
+        </section>
+
+        <section id="slow" class="section" style="text-align:left">
+            <h2>Why is it so SLOW?</h2>
+            <p>Everything happens client side, and the blob uploads take a while. Nothing runs in parallel. Blob uploads
+                happen one at a time; once one is done, the next goes. This is done just to keep it as simple as
+                possible and to hopefully limit the chance of failures on uploads. My personal account takes about
+                20-30ish mins to move with 1,700ish blobs at 800mb on a 1gig internet connection.</p>
+        </section>
+
+        <section id="open-source" class="section" style="text-align:left">
+            <h2>Can I check out the code anywhere?</h2>
+            <p>Yep! PDS MOOver is 100% open source and can find the code on <a
+                    href="https://tangled.sh/@baileytownsend.dev/pds-moover">tangled.sh</a>. Also, if you're a
+                developer,
+                and you want to fork the code for a new UI. PDS MOOver's logic is all in one js file. Just take it and
+                its dependencies and have at it.</p>
+        </section>
+    </div>
+
+</div>

web-ui/src/routes/missing-blobs/+page.svelte

···
+<script lang="ts">
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import missingPicture from '$lib/assets/missing.webp'
+    import {MissingBlobs} from '@pds-moover/moover';
+
+    let missingBlobs = $state(new MissingBlobs());
+
+    // Form state
+    let showCurrentLogin = $state(true);
+    let showOldLogin = $state(false);
+    let showAdvance = $state(false);
+    let disableLoginButton = $state(false);
+    let showBlobMoveProgress = $state(false);
+    let oldPdsUrl = $state<string | null>(null);
+    let showTryAgain = $state(false);
+    let errorMessage: string | null = $state(null);
+    let showStatusMessage = $state(false);
+    let statusMessage = $state('');
+
+    let loginForm = $state({
+        handle: '',
+        password: '',
+        twoFactorCode: '',
+        showTwoFactorCodeInput: false,
+    });
+
+
+    function resetStatusAndErrors() {
+        showStatusMessage = false;
+        statusMessage = '';
+        errorMessage = '';
+        disableLoginButton = true;
+    }
+
+    async function handleCurrentLogin(event: SubmitEvent) {
+        event.preventDefault();
+        resetStatusAndErrors();
+        try {
+            const {
+                accountStatus,
+                missingBlobsCount
+            } = await missingBlobs.currentAgentLogin(loginForm.handle, loginForm.password, loginForm.twoFactorCode);
+            console.log(missingBlobsCount);
+            const noMissingBlobs = missingBlobsCount === 0;
+            if (noMissingBlobs) {
+                statusMessage = `You are good to go! You are not missing any blobs. Your account has ${accountStatus.importedBlobs} imported blobs and expects to have at least ${accountStatus.expectedBlobs} blobs. No action is required.`
+            } else {
+                showCurrentLogin = false;
+                statusMessage = 'You are currently missing some blobs. Login with your old password to import the missing blobs. We will automatically find your old handle.';
+                showOldLogin = true;
+                //Reset the form
+                loginForm.showTwoFactorCodeInput = false;
+                loginForm.twoFactorCode = '';
+                loginForm.password = '';
+                loginForm.handle = '';
+            }
+            showStatusMessage = true;
+
+        } catch (err) {
+            //@ts-expect-error: Should always have an error message
+            if (err.error === 'AuthFactorTokenRequired') {
+                loginForm.showTwoFactorCodeInput = true;
+            }
+            //@ts-expect-error: Should always have an error message
+            errorMessage = err.message;
+        }
+        disableLoginButton = false;
+    }
+
+    async function handleOldLogin(event: SubmitEvent) {
+        event.preventDefault();
+        resetStatusAndErrors();
+        try {
+            await missingBlobs.oldAgentLogin(loginForm.password, loginForm.twoFactorCode, oldPdsUrl);
+            showOldLogin = false;
+            showBlobMoveProgress = true;
+            showStatusMessage = true;
+            statusMessage = '';
+            await migrateMissingBlobs();
+        } catch (err) {
+            //@ts-expect-error: Should always have an error message
+            if (err.error === 'AuthFactorTokenRequired') {
+                loginForm.showTwoFactorCodeInput = true;
+            }
+            //@ts-expect-error: Should always have an error message
+            errorMessage = err.message;
+        }
+        disableLoginButton = false;
+    }
+
+    function updateStatusHandler(status: string) {
+        console.log('Status update:', status);
+        statusMessage = status;
+    }
+
+    async function migrateMissingBlobs() {
+        try {
+            resetStatusAndErrors();
+            showStatusMessage = true;
+            showTryAgain = false;
+            const {
+                accountStatus,
+                missingBlobsCount
+            } = await missingBlobs.migrateMissingBlobs(updateStatusHandler);
+            const noMissingBlobs = missingBlobsCount === 0;
+            if (noMissingBlobs) {
+                statusMessage = `You are good to go! You have all ${accountStatus.importedBlobs} of the expected ${accountStatus.expectedBlobs} blobs. You're done!!`
+            } else {
+                statusMessage = `Expected blobs: ${accountStatus.expectedBlobs} Imported blobs: ${accountStatus.importedBlobs}`;
+                showTryAgain = true;
+            }
+        } catch (err) {
+            //@ts-expect-error: Should always have an error message
+            errorMessage = err.message;
+            showTryAgain = true;
+        }
+        disableLoginButton = false;
+    }
+
+    function toggleAdvanceMenu() {
+        showAdvance = !showAdvance;
+    }
+</script>
+
+<svelte:head>
+    <title>PDS MOOver - Missing Blobs</title>
+    <meta property="og:description" content="Import missing blobs from your old PDS to your new PDS"/>
+    <meta property="og:image" content="{missingPicture}">
+</svelte:head>
+
+{#snippet custom_img()}
+    <img src='{missingPicture}' alt='Cartoon milk cow on a missing poster'
+         style='max-width: 100%; max-height: 100%; object-fit: contain;'>
+{/snippet}
+
+<div class="container">
+    <MooHeader title="Missing Blobs Importer" customImg={custom_img}/>
+
+    <a href="https://blacksky.community/profile/did:plc:g7j6qok5us4hjqlwjxwrrkjm/post/3lyylumcpok2c">How to video
+        guide</a>
+
+    <!-- Login Form -->
+    {#if showCurrentLogin || showOldLogin}
+        <form id="moover-form" onsubmit={showCurrentLogin ? handleCurrentLogin : handleOldLogin}>
+            <div class="section">
+                <h2>{showCurrentLogin ? 'Login for your current PDS' : 'Password for your OLD PDS'}</h2>
+
+                {#if showOldLogin}
+                    <p>We only need your password for your old account. We can find your old handle from your current
+                        login.</p>
+                {/if}
+
+                {#if showCurrentLogin}
+                    <div class="form-group">
+                        <label for="handle">Current Handle:</label>
+                        <input type="text" id="handle" name="handle" placeholder="alice.bsky.social"
+                               bind:value={loginForm.handle}
+                               required>
+                    </div>
+                {/if}
+
+                <div class="form-group">
+                    <label for="password">{showCurrentLogin ? 'Current' : 'OLD'} Password:</label>
+                    <input type="password" id="password" name="password"
+                           bind:value={loginForm.password}
+                           required>
+                </div>
+
+                {#if (showCurrentLogin && loginForm.showTwoFactorCodeInput) || (showOldLogin && loginForm.showTwoFactorCodeInput)}
+                    <div class="form-group">
+                        <label for="two-factor-code">2FA from the email sent</label>
+                        <input type="text" id="two-factor-code" name="two-factor-code"
+                               bind:value={loginForm.twoFactorCode}>
+                        <div class="error-message">Enter your 2fa code here</div>
+                    </div>
+                {/if}
+
+                {#if showOldLogin}
+                    {#if showAdvance}
+                        <div class="form-group show-advance">
+                            <label for="old_pds">This is optional. If you do not know your old PDS url please leave it
+                                blank. We will find it for you.</label>
+                            <input type="url" id="old_pds" name="old-pds"
+                                   placeholder="(Optional) Your old PDS URL" bind:value={oldPdsUrl}>
+                        </div>
+                    {/if}
+                    <div class="form-group">
+                        <button type="button" onclick={toggleAdvanceMenu} id="advance" name="advance">Advance Options
+                        </button>
+                    </div>
+                {/if}
+
+                {#if errorMessage}
+                    <div class="error-message">{errorMessage}</div>
+                {/if}
+                {#if showStatusMessage}
+                    <div class="status-message">{statusMessage}</div>
+                {/if}
+
+                <div>
+                    <button disabled={disableLoginButton} type="submit">
+                        {showCurrentLogin ? 'Login' : 'Login and start the import of missing blobs'}
+                    </button>
+                </div>
+            </div>
+        </form>
+    {/if}
+
+    <!-- Progress while uploading blobs-->
+    {#if showBlobMoveProgress}
+        <div>
+            {#if showStatusMessage}
+                <div id="warning">*This will take a while. Please do not close this tab. And watch
+                    the status message below for updates
+                </div>
+                <div id="missing-status-message" class="status-message">{statusMessage}</div>
+            {/if}
+            {#if errorMessage}
+                <div class="error-message">{errorMessage}</div>
+            {/if}
+            {#if showTryAgain}
+                <p style="color: yellow">We were unable to import all of your previous blobs, please try again. If it is
+                    still not completing give it a few hours and come back and try again. It may be rate limited. Re
+                    running this tool does not harm your account.</p>
+                <br>
+                <button onclick={migrateMissingBlobs}>Try again</button>
+            {/if}
+        </div>
+    {/if}
+</div>

web-ui/src/routes/moover/+page.svelte

···
+<script lang="ts">
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import OgImage from '$lib/components/OgImage.svelte';
+    import {resolve} from '$app/paths';
+    import {Migrator} from '@pds-moover/moover';
+    import SignThePapers from './SignThePapers.svelte';
+
+    let formData = $state({
+        handle: '',
+        password: '',
+        newPds: '',
+        newEmail: '',
+        newHandle: '',
+        inviteCode: null,
+        twoFactorCode: null,
+        confirmation: false,
+        // Advanced options
+        createNewAccount: true,
+        migrateRepo: true,
+        migrateBlobs: true,
+        migrateMissingBlobs: true,
+        migratePrefs: true,
+        migratePlcRecord: true,
+    });
+
+    let migrator = $state(new Migrator());
+
+    //UI state
+    let showTwoFactorCodeInput = $state(false);
+    let showAdvance = $state(false);
+    let showStatusMessage = $state(false);
+    let askForPlcToken = $state(false);
+    let disableSubmit = $state(false);
+
+    let errorMessage: null | string = $state(null);
+    let statusMessage: null | string = $state(null);
+
+    const updateStatusHandler = (status: string) => {
+        statusMessage = status;
+    }
+
+    async function submitMoove(event: SubmitEvent & { currentTarget: EventTarget & HTMLFormElement }) {
+        event.preventDefault();
+        disableSubmit = true;
+        errorMessage = null;
+        showStatusMessage = false;
+
+        if (!formData.confirmation) {
+            errorMessage = 'Please confirm that you understand the risks of doing an account migration';
+            disableSubmit = false;
+            return;
+        }
+
+        try {
+
+            if (showTwoFactorCodeInput) {
+                if (showTwoFactorCodeInput === null) {
+                    errorMessage = 'Please enter the 2FA that was sent to your email.'
+                    disableSubmit = false;
+                    return;
+                }
+            }
+
+            // Advance options from $state
+            migrator.createNewAccount = formData.createNewAccount;
+            migrator.migrateRepo = formData.migrateRepo;
+            migrator.migrateBlobs = formData.migrateBlobs;
+            migrator.migrateMissingBlobs = formData.migrateMissingBlobs;
+            migrator.migratePrefs = formData.migratePrefs;
+            migrator.migratePlcRecord = formData.migratePlcRecord;
+
+            console.log(migrator);
+
+            updateStatusHandler('Starting migration...');
+            showStatusMessage = true;
+            await migrator.migrate(
+                formData.handle,
+                formData.password,
+                formData.newPds,
+                formData.newEmail,
+                formData.newHandle,
+                formData.inviteCode,
+                updateStatusHandler,
+                formData.twoFactorCode,
+            );
+            if (migrator.migratePlcRecord) {
+                //I don't think disable submit is needed, but you never know.
+                disableSubmit = false;
+                askForPlcToken = true;
+            } else {
+                updateStatusHandler('Migration of your repo is complete! But the PLC operation was not done so your old account is still the valid one.');
+            }
+        } catch (error) {
+            disableSubmit = false;
+            console.error(error);
+            //@ts-expect-error: JS being js. doesn't like not having the type'
+            if (error.error === 'AuthFactorTokenRequired') {
+                showTwoFactorCodeInput = true;
+            }
+            //@ts-expect-error: JS being js. doesn't like not having the type'
+            errorMessage = error.message;
+        }
+    }
+</script>
+
+<svelte:head>
+    <title>PDS MOOver</title>
+    <meta property="og:description" content="ATProto account migration tool"/>
+    <OgImage/>
+</svelte:head>
+
+<div class="container">
+    <MooHeader title="PDS MOOver"/>
+    {#if !askForPlcToken}
+        <a href={resolve('/info')}>Idk if I trust a cow to move my atproto account to a new PDS</a>
+        <br/>
+        <a href="https://blacksky.community/profile/did:plc:g7j6qok5us4hjqlwjxwrrkjm/post/3lw3hcuojck2u">Video guide for
+            joining blacksky.app</a>
+
+        <form id="moover-form" onsubmit={submitMoove}>
+            <!-- First section: Login credentials -->
+            <div class="section">
+                <h2>Login for your current PDS</h2>
+                <div class="form-group">
+                    <label for="handle">Old Handle:</label>
+                    <input type="text" id="handle" name="handle" placeholder="alice.bsky.social" required
+                           bind:value={formData.handle}>
+                </div>
+
+                <div class="form-group">
+                    <label for="password">Old Password (Will also be your new password):</label>
+                    <input type="password" id="password" name="password" required bind:value={formData.password}>
+                </div>
+                {#if showTwoFactorCodeInput}
+                    <div class="form-group">
+                        <label for="two-factor-code">2FA from the email sent</label>
+                        <input type="text" id="two-factor-code" name="twoFactorCode"
+                               bind:value={formData.twoFactorCode}>
+                        <div class="error-message">Enter your 2fa code here</div>
+
+                    </div>
+                {/if}
+            </div>
+
+            <!-- Second section: New account details -->
+            <div class="section">
+                <h2>Setup for the new PDS</h2>
+                <div class="form-group">
+                    <label for="new-pds">New PDS (URL):</label>
+                    <input type="url" id="new-pds" name="newPds" placeholder="https://coolnewpds.com"
+                           required bind:value={formData.newPds}>
+                </div>
+
+                <div class="form-group">
+                    <label for="new-email">New Email:</label>
+                    <input type="email" id="new-email" name="newEmail" placeholder="[e-mail]"
+                           required bind:value={formData.newEmail}>
+                </div>
+
+                <div class="form-group">
+                    <label for="new-handle">New Handle:</label>
+                    <input type="text" id="new-handle" name="newHandle"
+                           placeholder="username.newpds.com or mycooldomain.com" required
+                           bind:value={formData.newHandle}>
+                </div>
+
+                <div class="form-group">
+                    <label for="invite-code">Invite Code:</label>
+                    <input type="text" id="invite-code" name="inviteCode"
+                           placeholder="Invite code from your new PDS (Leave blank if you don't have one)"
+                           bind:value={formData.inviteCode}>
+                </div>
+            </div>
+
+            <div class="form-group">
+                <button type="button" onclick={() => showAdvance = !showAdvance} id="advance" name="advance">Advance
+                    Options
+                </button>
+            </div>
+            {#if showAdvance}
+                <div class="section" style="padding-bottom: 10px; text-align: left">
+                    <h3>Pick and choose which actions to run</h3>
+                    <p>Useful if a migration failed and you want to have a bit more manual control</p>
+                    <div class="form-control">
+                        <label class="moove-checkbox-label">
+                            <input type="checkbox" id="createNewAccount" name="createNewAccount"
+                                   bind:checked={formData.createNewAccount}>
+                            Create a New Account on the New PDS
+                        </label>
+                    </div>
+                    <div class="form-control">
+                        <label class="moove-checkbox-label">
+                            <input bind:checked={formData.migrateRepo} type="checkbox" id="migrateRepo"
+                                   name="migrateRepo">
+                            Migrate Repo
+                        </label>
+                    </div>
+                    <div class="form-control">
+                        <label class="moove-checkbox-label">
+                            <input bind:checked={formData.migrateBlobs} type="checkbox" id="migrateBlobs"
+                                   name="migrateBlobs">
+                            Migrate Blobs
+                        </label>
+                    </div>
+                    <div class="form-control">
+                        <label class="moove-checkbox-label">
+                            <input bind:checked={formData.migrateMissingBlobs} type="checkbox" id="migrateMissingBlobs"
+                                   name="migrateMissingBlobs">
+                            Migrate Missing Blobs
+                        </label>
+                    </div>
+                    <div class="form-control">
+                        <label class="moove-checkbox-label">
+                            <input bind:checked={formData.migratePrefs} type="checkbox" id="migratePrefs"
+                                   name="migratePrefs">
+                            Migrate Prefs
+                        </label>
+                    </div>
+                    <div class="form-control">
+                        <label class="moove-checkbox-label">
+                            <input bind:checked={formData.migratePlcRecord} type="checkbox" id="migratePlcRecord"
+                                   name="migratePlcRecord">
+                            Migrate PLC Record
+                        </label>
+                    </div>
+
+                </div>
+            {/if}
+
+            <p style="text-align: left">There are some risks that come with doing an account migration.
+                (Can view them
+                <a href="https://github.com/bluesky-social/pds/blob/main/ACCOUNT_MIGRATION.md#%EF%B8%8F-warning-%EF%B8%8F-%EF%B8%8F">here</a>)
+                and that the creator or host of this migration tool is not liable and will not be able to help you in
+                the
+                event something goes wrong. I also have read over the <a href={resolve('/info')}>extended information
+                    from
+                    PDS MOOver
+                    about account
+                    migrations.</a>
+            </p>
+            <div class="form-group">
+                <label for="confirmation" class="moove-checkbox-label">
+                    <input bind:checked={formData.confirmation} type="checkbox" id="confirmation" name="confirmation"
+                           required>
+                    <span>I understand</span>
+                </label>
+            </div>
+            {#if errorMessage !== null}
+                <div class="error-message">{errorMessage}</div>
+            {/if}
+
+            {#if showStatusMessage}
+                <div id="warning">*Please make sure to stay on this page during the MOOve for the
+                    best result
+                </div>
+                <div id="status-message" class="status-message">{statusMessage}</div>
+            {/if}
+
+            <div>
+                <button disabled={disableSubmit} type="submit">MOOve</button>
+            </div>
+        </form>
+
+    {:else}
+        <SignThePapers migrator={migrator} newHandle={formData.newHandle}/>
+    {/if}
+</div>

web-ui/src/routes/moover/SignThePapers.svelte

···
+<script lang="ts">
+    import {Migrator, PlcOps} from '@pds-moover/moover'
+    import {resolve} from '$app/paths'
+    import RotationKeyDisplay from '$lib/components/RotationKeyDisplay.svelte';
+    import type {RotationKeyType} from '$lib/types';
+    import {PUBLIC_XRPC_BASE} from '$env/static/public';
+
+    let {migrator, newHandle}: { migrator: Migrator, newHandle: string } = $props();
+
+    //UI State
+    let errorMessage: null | string = $state(null);
+    let done = $state(false);
+    let plcStatus: null | string = $state(null);
+    let showAdvancedPlcOptions = $state(false);
+    let backupSignupMessage: null | string = $state(null);
+    let backupSignupError: null | string = $state(null);
+
+    //Input State
+    let createANewRotationKey = $state(false);
+    let signupForBackups = $state(false);
+    let plcToken = $state('');
+    let rotationKeys = $state(['', '', '', '']);
+    let newlyCreatedRotationKey: RotationKeyType | null = $state(null);
+
+
+    async function signPlcOperation(event: SubmitEvent & { currentTarget: EventTarget & HTMLFormElement }) {
+        event.preventDefault();
+        try {
+            plcStatus = 'Signing PLC operation...';
+            backupSignupMessage = null;
+            backupSignupError = null;
+            // Build an additional rotation keys list (user-provided and/or newly created)
+            const additionalRotationKeysToAdd: string[] = [];
+            // Generate a new rotation key if requested
+            if (createANewRotationKey) {
+
+                let plcOps = new PlcOps();
+                const created = await plcOps.createANewSecp256k1();
+                newlyCreatedRotationKey = created; // { publicKey, privateKey }
+                // Reserve the first slot for the newly created key (will appear above the PDS rotation key)
+                additionalRotationKeysToAdd.push(created.publicKey);
+            }
+            // Append any manually entered rotation keys (non-empty)
+            //TODO idk about this i need to look at it again
+            for (let i = 0; i < rotationKeys.length; i++) {
+                const k = (rotationKeys[i] || '').trim();
+                if (k) {
+                    additionalRotationKeysToAdd.push(k);
+                }
+            }
+
+            //TODO nervous about this state
+            await migrator.signPlcOperation(plcToken, additionalRotationKeysToAdd);
+            plcStatus = 'PLC operation signed successfully! Your account has been MOOved to the new PDS.';
+            done = true;
+
+            if (signupForBackups) {
+                try {
+                    backupSignupMessage = 'Signing you up for automated backups...';
+                    //TODO nervous about this state
+                    await migrator.signUpForBackupsFromMigration(`did:web:${PUBLIC_XRPC_BASE}`);
+                    backupSignupMessage = 'Signed up for automated backups successfully.';
+                } catch (e) {
+                    console.error(e);
+                    //@ts-expect-error: There is a e.message, or at least a check for it
+                    backupSignupError = e?.message || 'Failed to sign you up for automated backups.';
+                }
+            }
+        } catch (error) {
+            //@ts-expect-error: There is a message
+            errorMessage = error.message;
+            console.error(error);
+        }
+    }
+
+</script>
+
+
+<div class="section">
+    <form onsubmit="{signPlcOperation}">
+        {#if !done}
+            <div>
+                <h2>Please enter your PLC Token you received in an email</h2>
+                <div class="form-group">
+                    <label for="plc-token">PLC Token:</label>
+                    <input type="text" id="plc-token" name="plc-token" bind:value={plcToken} required>
+                </div>
+                <p style="text-align: left">You can now select to add a new Rotation Key during migration and sign up
+                    for PDS MOOver's free backup service. With a Rotation Key and backups if your new PDS ever goes down
+                    you can recover your account and it's data.</p>
+                <div class="form-group">
+                    <label for="rotation-key" class="moove-checkbox-label">
+                        <input bind:checked={createANewRotationKey} type="checkbox" id="rotation-key"
+                               name="rotation-key">
+                        <span>Create and add a new Rotation Key</span>
+                    </label>
+                </div>
+                <div class="form-group">
+                    <label for="backups-signup" class="moove-checkbox-label">
+                        <input bind:checked={signupForBackups} type="checkbox" id="backups-signup"
+                               name="backups-signup">
+                        <span>Signup for automated account backups</span>
+                    </label>
+                </div>
+                <div class="form-group">
+                    <button type="button" id="plc-advance"
+                            onclick={() => showAdvancedPlcOptions = !showAdvancedPlcOptions}>Add
+                        Additional Rotation Keys
+                    </button>
+                </div>
+                {#if showAdvancedPlcOptions}
+                    <div class="section" style="padding-bottom: 10px;">
+                        <div style="text-align: left;">
+                            You can pick up to 4 rotation keys to your PLC document. These will appear above your new
+                            PDS
+                            rotation key so you can recover your account in the event of an adversarial take over from a
+                            rogue PDS
+                        </div>
+                        <div class="form-group" style="margin-top: 10px;">
+                            <label for="rotation-key-1">Rotation key 1</label>
+                            <input type="text" id="rotation-key-1" name="rotation-key-1"
+                                   bind:value={rotationKeys[0]}
+                                   disabled={createANewRotationKey}
+                                   placeholder={createANewRotationKey ? 'reserved for the newly created rotation key' : ''}>
+                        </div>
+                        <div class="form-group">
+                            <label for="rotation-key-2">Rotation key 2</label>
+                            <input type="text" id="rotation-key-2" name="rotation-key-2" bind:value={rotationKeys[1]}>
+                        </div>
+                        <div class="form-group">
+                            <label for="rotation-key-3">Rotation key 3</label>
+                            <input type="text" id="rotation-key-3" name="rotation-key-3" bind:value={rotationKeys[2]}>
+                        </div>
+                        <div class="form-group">
+                            <label for="rotation-key-4">Rotation key 4</label>
+                            <input type="text" id="rotation-key-4" name="rotation-key-4" bind:value={rotationKeys[3]}>
+                        </div>
+                    </div>
+                {/if}
+            </div>
+        {/if}
+        {#if errorMessage}
+            <div class="error-message">{errorMessage}</div>
+        {/if}
+
+        {#if done && createANewRotationKey && newlyCreatedRotationKey}
+            <div>
+                <RotationKeyDisplay handle={newHandle} rotationKey={newlyCreatedRotationKey}/>
+            </div>
+        {/if}
+
+        {#if !done && plcStatus}
+            <div class="status-message">{plcStatus}</div>
+        {/if}
+
+        {#if signupForBackups && backupSignupMessage}
+            <div>
+                <div class="status-message">{backupSignupMessage}</div>
+                {#if backupSignupError}
+                    <div class="error-message">{backupSignupError}</div>
+                {/if}
+
+            </div>
+        {/if}
+
+        {#if done}
+            <div class="status-message">Congratulations! You have MOOved to a new PDS! Remember to use
+                your new PDS URL under "Hosting provider" when logging in on Bluesky. Can find more detail information
+                <a href={resolve('/info#cant-login')}>here.</a></div>
+        {:else }
+            <div>
+                <button type="submit">Sign the papers</button>
+            </div>
+        {/if}
+
+
+    </form>
+</div>

web-ui/src/routes/restore/+page.svelte

···
+<script lang="ts">
+    import {Restore} from '@pds-moover/moover';
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import LoadingSpinner from '$lib/components/LoadingSpinner.svelte';
+    import {PUBLIC_XRPC_BASE} from '$env/static/public';
+    import OgImage from '$lib/components/OgImage.svelte';
+
+    //Regexs to catch rotation key type
+    const HEX_REGEX = /^[0-9a-f]+$/i;
+
+    // Service instances
+    let restoreService = $state(new Restore(`https://${PUBLIC_XRPC_BASE}`));
+
+    // Form inputs
+    let currentHandle = $state('');
+    let rotationKey = $state('');
+    let newPds = $state('');
+    let newHandle = $state('');
+    let newPassword = $state('');
+    let newEmail = $state('');
+    let inviteCode = $state('');
+    let cid = $state('');
+
+    // Rotation key type detection and selection
+    let isHexKey = $state(false);
+    let rotationKeyType = $state<'secp256k1' | 'p256'>('secp256k1');
+
+    // Advanced options
+    let restoreFilesFromBackup = $state(true);
+    let recoverAccount = $state(true);
+
+    // UI state
+    let errorMessage = $state<string | null>(null);
+    let showStatusMessage = $state(false);
+    let showAdvanced = $state(false);
+    let done = $state(false);
+    let statusMessageText = $state('');
+    let isSubmitting = $state(false);
+
+    function setStatus(message: string) {
+        console.log('Status update:', message);
+        statusMessageText = message;
+        showStatusMessage = true;
+    }
+
+    function handleRotationKeyChange() {
+        const trimmedKey = rotationKey.trim();
+        if (trimmedKey && HEX_REGEX.test(trimmedKey)) {
+            isHexKey = true;
+        } else {
+            isHexKey = false;
+        }
+    }
+
+    async function handleSubmit() {
+        errorMessage = null;
+        showStatusMessage = false;
+        isSubmitting = true;
+
+        try {
+            restoreService.RestoreFromBackup = restoreFilesFromBackup;
+            restoreService.AccountRecovery = recoverAccount;
+
+            await restoreService.recover(
+                rotationKey,
+                rotationKeyType,
+                currentHandle,
+                newPds,
+                newHandle,
+                newPassword,
+                newEmail,
+                inviteCode || null,
+                cid || null,
+                setStatus
+            );
+            done = true;
+        } catch (e) {
+            console.error(e);
+            // @ts-expect-error: Error is handled
+            errorMessage = e.message || 'An error occurred';
+        } finally {
+            isSubmitting = false;
+        }
+    }
+</script>
+
+<svelte:head>
+    <title>PDS MOOver - Restore</title>
+    <meta property="og:description" content="Recovery and restore your ATProto account"/>
+    <OgImage/>
+</svelte:head>
+
+<div class="container">
+    <MooHeader title="Restore"/>
+
+    <div class="section">
+        <p style="text-align: left">
+            Use this page to restore your AT Protocol account on a new PDS using your private rotation
+            key. It's intended to be used in the worst case scenario, and not for normal account
+            migrations. We do not need your password since your rotation key is what is used to recover
+            your account. Once your account has been moved to a new PDS we will also attempt to restore
+            your repo and blobs(pictures/videos) from our backups.
+        </p>
+    </div>
+
+    {#if !done}
+        <form
+                id="restore-form"
+                onsubmit={(e) => {
+				e.preventDefault();
+				handleSubmit();
+			}}
+        >
+            <div class="form-group">
+                <label for="current-handle"
+                >Your current handle or did (found in the recovery rotation-key.txt)</label
+                >
+                <input
+                        id="current-handle"
+                        bind:value={currentHandle}
+                        placeholder="did:plc:rnpkyqnmsw4ipey6eotbdnnf"
+                        required
+                />
+            </div>
+
+            {#if recoverAccount}
+                <div class="form-group">
+                    <label for="rotationKey">Private Rotation Key</label>
+                    <input
+                            id="rotationKey"
+                            bind:value={rotationKey}
+                            oninput={handleRotationKeyChange}
+                            placeholder="a secp256k1 or p256 in either hex or multikey format"
+                            required={recoverAccount}
+                    />
+                </div>
+
+                {#if isHexKey}
+                    <div class="form-group">
+                        <fieldset style="border: none; padding: 0; margin: 0;">
+                            <legend style="margin-bottom: 0.5rem;">Rotation Key Type</legend>
+                            <div style="display: flex; gap: 1rem;">
+                                <label style="display: flex; align-items: center; gap: 0.5rem; cursor: pointer;">
+                                    <input
+                                            type="radio"
+                                            name="rotationKeyType"
+                                            value="secp256k1"
+                                            bind:group={rotationKeyType}
+                                    />
+                                    secp256k1
+                                </label>
+                                <label style="display: flex; align-items: center; gap: 0.5rem; cursor: pointer;">
+                                    <input
+                                            type="radio"
+                                            name="rotationKeyType"
+                                            value="p256"
+                                            bind:group={rotationKeyType}
+                                    />
+                                    p256
+                                </label>
+                            </div>
+                            <small class="help-text">Select the type of your hex-encoded rotation key</small>
+                        </fieldset>
+                    </div>
+                {/if}
+            {/if}
+
+            <div class="form-group">
+                <label for="newPds">New PDS</label>
+                <input
+                        id="newPds"
+                        type="text"
+                        bind:value={newPds}
+                        placeholder="https://newpds.com"
+                        required
+                />
+            </div>
+
+            <div class="form-group">
+                <label for="newHandle">New Handle</label>
+                <input
+                        id="newHandle"
+                        type="text"
+                        bind:value={newHandle}
+                        placeholder="you.newpds.com or thisisme.com"
+                        required
+                />
+            </div>
+
+            <div class="form-group">
+                <label for="newPassword">New Password</label>
+                <input id="newPassword" type="password" bind:value={newPassword} required/>
+            </div>
+
+            <div class="form-group">
+                <label for="newEmail">New Email</label>
+                <input
+                        id="newEmail"
+                        type="email"
+                        bind:value={newEmail}
+                        placeholder="[e-mail]"
+                        required
+                />
+            </div>
+
+            <div class="form-group">
+                <label for="inviteCode">Invite code (optional)</label>
+                <input id="inviteCode" type="text" bind:value={inviteCode} placeholder="Optional"/>
+            </div>
+
+            <div class="form-group">
+                <button type="button" onclick={() => (showAdvanced = !showAdvanced)}>
+                    {showAdvanced ? 'Hide advanced options' : 'Show advanced options'}
+                </button>
+            </div>
+
+            {#if showAdvanced}
+                <div class="advanced-options">
+                    <div class="form-group">
+                        <label class="moove-checkbox-label">
+                            <input
+                                    id="recoverAccount"
+                                    type="checkbox"
+                                    bind:checked={recoverAccount}
+                            />
+                            Recover the did doc & account.
+                        </label>
+                        <br/>
+                        <small class="help-text">This option temporary assigns a signing key to your did doc, uses it to
+                            create a new account on the new PDS with your did, and migrates the account to the new
+                            PDS.</small>
+                    </div>
+
+                    <div class="form-group">
+                        <label class="moove-checkbox-label">
+                            <input
+                                    id="restoreFilesFromBackup"
+                                    type="checkbox"
+                                    bind:checked={restoreFilesFromBackup}
+                            />
+                            Restores files from backup.
+                        </label>
+                    </div>
+
+                    {#if recoverAccount}
+                        <div class="form-group">
+                            <label for="cid">Cid (optional)</label>
+                            <input
+                                    id="cid"
+                                    type="text"
+                                    bind:value={cid}
+                                    placeholder="Specific PLC audit log CID to restore to (advanced)"
+                            />
+                            <small class="help-text"
+                            >Leave empty for normal restore. IF someone besides you changed your did doc and
+                                stole your atproto identity or a mistake was made you have up to 72hrs to reverse that
+                                change with a valid
+                                rotation key from the last valid operation. This input allows you to restore to the
+                                last good PLC op via it's
+                                CID.</small
+                            >
+                        </div>
+                    {/if}
+                </div>
+            {/if}
+
+            {#if errorMessage}
+                <div class="error-message">{errorMessage}</div>
+            {/if}
+            {#if showStatusMessage}
+                <div class="status-message">{statusMessageText}</div>
+            {/if}
+
+            <div class="form-actions">
+                <button type="submit" disabled={isSubmitting}>
+                    {#if isSubmitting}
+                        <LoadingSpinner/>
+                    {/if}
+                    Recover and restore your account
+                </button>
+            </div>
+        </form>
+    {/if}
+
+    <!-- Done -->
+    {#if done}
+        <div class="section">
+            <div class="status-message">
+                Congratulations! You have successfully recovered your account! Remember to use your new
+                PDS URL under "Hosting provider" when logging in on Bluesky. Can find more detail
+                information
+                <a href="/info#cant-login">here.</a>
+            </div>
+        </div>
+    {/if}
+</div>

web-ui/src/routes/rotation-key/+page.svelte

···
+<script lang="ts">
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import {PlcOps} from '@pds-moover/moover';
+    import type {RotationKeyType} from '$lib/types';
+    import RotationKeyDisplay from '$lib/components/RotationKeyDisplay.svelte';
+
+    let handle: string = $state('');
+    let errorMessage: null | string = $state(null);
+    let status: null | string = $state(null);
+    let newlyCreatedRotationPrivateKey: null | RotationKeyType = $state(null);
+
+
+    const generateNewKey = async () => {
+        errorMessage = null;
+        status = 'Generating a new rotation key…';
+        try {
+            const plcOps = new PlcOps();
+            newlyCreatedRotationPrivateKey = await plcOps.createANewSecp256k1();
+            status = 'New rotation key generated.';
+        } catch (e) {
+            console.error(e);
+            // @ts-expect-error: already checked for null
+            errorMessage = e?.message || 'Failed to generate a new rotation key';
+            status = null;
+        }
+    };
+
+</script>
+
+
+<div class="container">
+
+    <MooHeader title="Rotation Key"/>
+    <div class="section">
+        <p style="text-align: left;">This page is intended for development and is not listed. This will NOT save a key
+            to your account.</p>
+        <div class="form-group">
+            <label for="handle">Handle</label>
+            <input bind:value={handle} type="text" id="handle" name="handle" placeholder="Enter your handle"/>
+        </div>
+        <div class="form-group">
+            <button type="button" onclick={generateNewKey}>Generate New Rotation Key</button>
+        </div>
+    </div>
+
+    {#if status}
+        <div class="status-message">{status}</div>
+    {/if}
+
+    {#if errorMessage}
+        <div class="error-message">{errorMessage}</div>
+    {/if}
+
+
+    {#if newlyCreatedRotationPrivateKey}
+        <RotationKeyDisplay handle={handle} rotationKey={newlyCreatedRotationPrivateKey}/>
+    {/if}
+
+</div>

web-ui/src/routes/terms/+page.svelte

···
+<script lang="ts">
+    import OgImage from '$lib/components/OgImage.svelte';
+</script>
+
+<svelte:head>
+    <title>PDS MOOver - Legal</title>
+    <meta name="description" content="Terms of Service and Privacy Policy for PDS MOOver"/>
+    <meta property="og:description" content="Terms of Service and Privacy Policy for PDS MOOver"/>
+    <OgImage/>
+</svelte:head>
+
+<div class="container" style="text-align:left">
+    <section class="section">
+
+        <h1>Privacy Policy</h1>
+        <p>Last updated: 2025-10-20</p>
+
+        <h2>Overview</h2>
+        <p>PDS MOOver performs migrations in your browser. Where possible, operations are client side to minimize
+            collection of personal data by the server. Backups happen on our servers, and your data is stored in a cloud
+            base object store we have access to</p>
+
+        <h2>Information We May Receive</h2>
+        <ul>
+            <li>If you use optional features (e.g., backups), we take a backup of your AT Proto repo when it has a
+                change, any blobs you have posted to your account are stored in a <a target="_blank"
+                                                                                     rel="noopener noreferrer"
+                                                                                     href="https://en.wikipedia.org/wiki/Object_storage">object
+                    store</a> that we control. Just like your <a target="_blank" rel="noopener noreferrer"
+                                                                 href="https://blueskyweb.zendesk.com/hc/en-us/articles/15835264007693-Data-Privacy">AT
+                    Proto data</a> this is public and accessible to anyone. But this does not mean anyone is able to
+                take this data and impersonate you without what is known as a Rotation Key.
+            </li>
+        </ul>
+
+        <h2>What We Do Not Do</h2>
+        <ul>
+            <li>If you use PDS MOOver just for migrations, missing blobs, or turn off feature. We do not collect or
+                store any information. This happens all client side.
+            </li>
+            <li>We do not collect any personal information beyond your current PDS host and your DID if you sign up for
+                backups.
+            </li>
+            <li>Your passwords are only ever sent to your PDS. Your passwords are never collected, and all authenticated
+                requests happen proxied via your PDS to our services for backups
+            </li>
+        </ul>
+
+        <h2>Retention</h2>
+        <p>Server-side logs may be retained for a limited time for security, debugging, and rate-limiting. This is short
+            term logging and cleared on instance reboots and kept no longer than 60 days. Backup-related data, if
+            enabled by you, is stored indefinitely for the life of this service unless you opt out via <a
+                    href="/backups">backups</a> and click delete to remove all of your backups and from any future ones.
+        </p>
+
+        <h2>Your Choices</h2>
+        <p>You may choose not to use the service. If you proceed, ensure you have backups and understand the migration
+            risks. If you ever want to be removed from our services you can also login via <a
+                    href="/backups">backups</a> and click delete to remove all of your backups and from any future ones.
+        </p>
+
+        <h2>Changes</h2>
+        <p>We may update this Privacy Policy from time to time. Continued use after changes means you accept the updated
+            policy.</p>
+
+        <h2>Service Provider and Location</h2>
+        <p>All backup data is currently being stored on <a href="https://upcloud.com/">UpCloud's</a> <a
+                href="https://upcloud.com/products/object-storage/">object store</a> in a data center located in the US.
+            UpCloud is also our service provider for the VPS running the services. We may change service providers in
+            the future, if we do this terms of service will be updated to reflect that.</p>
+
+    </section>
+
+    <section class="section">
+        <h1>Terms of Service</h1>
+        <p>Last updated: 2025-10-20</p>
+
+        <p>PDS MOOver is provided on an as-is and as-available basis, without warranties of any kind. By using this site
+            and its tools, you agree that you understand the risks of migrating and or restoring ATProto/Bluesky
+            accounts and that neither the creator nor the host of this tool is responsible for any loss, corruption, or
+            unavailability of data, accounts, or services.</p>
+
+        <h2>Acceptable Use</h2>
+        <p>You agree not to misuse the service, disrupt other users, or attempt to gain unauthorized access to systems
+            or data. You are responsible for complying with applicable laws and policies of your hosting
+            provider(s).</p>
+
+        <h2>Limitation of Liability</h2>
+        <p>To the fullest extent permitted by law, the creator and host are not liable for any indirect, incidental,
+            special, consequential, or punitive damages, or any loss of data, profits, or revenues, whether incurred
+            directly or indirectly, resulting from your use of the service.</p>
+
+        <h2>Changes to the Service</h2>
+        <p>Features may change, be limited, or be discontinued at any time without notice.</p>
+
+        <h2>Backup User Content</h2>
+        <p>In extreme circumstances we reserve the right to ban, block, and or remove your content placed on our servers
+            if it is found to be illegal or harmful. We will notify you via Bluesky that you are being removed along
+            with giving you an export of your backed-up data.</p>
+
+        <h2>Contact</h2>
+        <p>If you have questions about these terms, please reach out via the project repository or to <a
+                href="https://bsky.app/profile/baileytownsend.dev">@baileytownsend.dev</a> directly.</p>
+    </section>
+</div>

web-ui/src/routes/turn-off/+page.svelte

···
+<script lang="ts">
+    import MooHeader from '$lib/components/MooHeader.svelte';
+    import {Migrator} from '@pds-moover/moover';
+    import OgImage from '$lib/components/OgImage.svelte';
+
+    let migrator = $state(new Migrator());
+
+    // Form state
+    let oldHandle = $state('');
+    let oldPassword = $state('');
+    let twoFactorCode = $state('');
+    let showTwoFactorCodeInput = $state(false);
+    let errorMessage: string | null = $state(null);
+    let showStatusMessage = $state(false);
+    let statusMessage = $state('');
+
+    function updateStatusHandler(status: string) {
+        console.log('Status update:', status);
+        statusMessage = status;
+    }
+
+    async function handleSubmit(event: SubmitEvent) {
+        event.preventDefault();
+        errorMessage = null;
+        showStatusMessage = false;
+
+
+        try {
+            if (showTwoFactorCodeInput) {
+                if (twoFactorCode === null || twoFactorCode === '') {
+                    errorMessage = 'Please enter the 2FA that was sent to your email.';
+                    return;
+                }
+            }
+
+            showStatusMessage = true;
+            await migrator.deactivateOldAccount(
+                oldHandle,
+                oldPassword,
+                updateStatusHandler,
+                twoFactorCode
+            );
+        } catch (err) {
+            //@ts-expect-error: error should be fine
+            if (err.error === 'AuthFactorTokenRequired') {
+                showTwoFactorCodeInput = true;
+            }
+            //@ts-expect-error: error should be fine
+            errorMessage = err.message;
+        }
+    }
+</script>
+
+<svelte:head>
+    <title>PDS MOOver - Turn OFF</title>
+    <meta property="og:description" content="Deactivate your old account"/>
+    <OgImage/>
+</svelte:head>
+
+<div class="container">
+    <MooHeader title="Turn OFF"/>
+
+    <p>Use this page to make sure your old account is deactivated</p>
+
+    <form id="moover-form" onsubmit={handleSubmit}>
+        <!-- Login credentials -->
+        <div class="section">
+            <h2>Login for your old PDS</h2>
+            <div class="form-group">
+                <label for="handle">Old Handle:</label>
+                <input type="text" id="handle" name="handle" placeholder="alice.bsky.social"
+                       bind:value={oldHandle}
+                       required>
+            </div>
+
+            <div class="form-group">
+                <label for="password">Old Password:</label>
+                <input type="password" id="password" name="password" bind:value={oldPassword} required>
+            </div>
+
+            {#if showTwoFactorCodeInput}
+                <div class="form-group">
+                    <label for="two-factor-code">2FA from the email sent</label>
+                    <input type="text" id="two-factor-code" name="two-factor-code" bind:value={twoFactorCode}>
+                    <div class="error-message">Enter your 2fa code here</div>
+                </div>
+            {/if}
+        </div>
+
+        {#if errorMessage}
+            <div class="error-message">{errorMessage}</div>
+        {/if}
+        {#if showStatusMessage}
+            <div id="status-message" class="status-message">{statusMessage}</div>
+        {/if}
+
+        <div>
+            <button type="submit">Turn it off</button>
+        </div>
+    </form>
+</div>

web-ui/src/routes/turnoff.html/+server.ts

···
+import { redirect } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+
+export const GET: RequestHandler = () => {
+	throw redirect(301, '/turn-off');
+};

web-ui/static/robots.txt

···
+# allow crawling everything by default
+User-agent: *
+Disallow:

web-ui/svelte.config.js

···
+import adapter from '@sveltejs/adapter-node';
+import {vitePreprocess} from '@sveltejs/vite-plugin-svelte';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+    // Consult https://svelte.dev/docs/kit/integrations
+    // for more information about preprocessors
+    preprocess: vitePreprocess(),
+
+    kit: {
+        // https://svelte.dev/docs/kit/adapter-node
+        adapter: adapter()
+    }
+};
+
+export default config;

web-ui/tsconfig.json

···
+{
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "bundler",
+    "types": [
+      "@pds-moover/lexicon_types"
+    ]
+  }
+  // Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
+  // except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
+  //
+  // To make changes to top-level options such as include and exclude, we recommend extending
+  // the generated config; see https://svelte.dev/docs/kit/configuration#typescript
+}

web-ui/vite.config.ts

···
+import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+	plugins: [sveltekit()]
+});

web/Cargo.toml

···
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 dotenvy.workspace = true
-askama = "0.14"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 anyhow.workspace = true
 log.workspace = true
 shared = { path = "../shared" }
-vite-rust = "0.2.4"
-tower-http = { version = "0.6.1", features = ["fs", "trace"] }
+tower-http = { version = "0.6.1", features = ["fs", "trace", "cors"] }
 tower = { version = "0.5.1", features = ["util"] }
 jacquard-axum.workspace = true
 jacquard-common.workspace = true

web/public/style.css web-ui/src/lib/assets/style.css

···
 
 a {
     font-weight: 500;
-    color: #646cff;
+    color: #a2a7ff;
     text-decoration: inherit;
     text-decoration: underline;
 }

web/src/handlers/mod.rs

···
-pub mod pages;
 pub mod well_known;
 pub mod xrpc;

web/src/handlers/pages.rs

···
-use crate::AppState;
-use crate::templates::{
-    BackupsPage, HtmlTemplate, IndexPage, InfoPage, LayoutContext, MissingBlobsPage, MooverPage,
-    RestorePage, RotationKeyPage, TermsPrivacyPage, TurnOffPage, error_response,
-};
-use axum::Router;
-use axum::extract::State;
-use axum::http::StatusCode;
-use axum::response::{IntoResponse, Response};
-use axum::routing::get;
-
-pub async fn index_handler(State(state): State<AppState>) -> Result<impl IntoResponse, Response> {
-    let layout = LayoutContext::new("PDS MOOver".to_string(), state.vite, "/").map_err(|err| {
-        tracing::error!(?err, "Error rendering out the index page");
-        error_response(
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "Error rendering out the index page",
-        )
-    })?;
-
-    Ok(HtmlTemplate(IndexPage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn moover_handler(State(state): State<AppState>) -> Result<impl IntoResponse, Response> {
-    let layout =
-        LayoutContext::new("PDS MOOver".to_string(), state.vite, "/moover").map_err(|err| {
-            tracing::error!(?err, "Error rendering out the index page");
-            error_response(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Error rendering out the index page",
-            )
-        })?;
-
-    Ok(HtmlTemplate(MooverPage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn info_handler(State(state): State<AppState>) -> Result<impl IntoResponse, Response> {
-    let layout = LayoutContext::new("PDS MOOver - Info".to_string(), state.vite, "/info").map_err(
-        |err| {
-            tracing::error!(?err, "Error rendering out the index page");
-            error_response(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Error rendering out the index page",
-            )
-        },
-    )?;
-
-    Ok(HtmlTemplate(InfoPage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn turn_off_handler(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, Response> {
-    let layout = LayoutContext::new("PDS MOOver - Turn OFF".to_string(), state.vite, "/turn-off")
-        .map_err(|err| {
-        tracing::error!(?err, "Error rendering out the index page");
-        error_response(
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "Error rendering out the index page",
-        )
-    })?;
-
-    Ok(HtmlTemplate(TurnOffPage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn missing_blobs_handler(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, Response> {
-    let layout = LayoutContext::new(
-        "Import Missing Blobs".to_string(),
-        state.vite,
-        "/missing-blobs",
-    )
-    .map_err(|err| {
-        tracing::error!(?err, "Error rendering out the index page");
-        error_response(
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "Error rendering out the index page",
-        )
-    })?;
-
-    Ok(HtmlTemplate(MissingBlobsPage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn backups_signup_handler(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, Response> {
-    let layout = LayoutContext::new("Backups - Signup".to_string(), state.vite, "/backups")
-        .map_err(|err| {
-            tracing::error!(?err, "Error rendering out the index page");
-            error_response(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Error rendering out the index page",
-            )
-        })?;
-
-    Ok(HtmlTemplate(BackupsPage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn rotation_key_handler(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, Response> {
-    let layout = LayoutContext::new("Rotation Key".to_string(), state.vite, "/rotation-key")
-        .map_err(|err| {
-            tracing::error!(?err, "Error rendering out the rotation key page");
-            error_response(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Error rendering out the rotation key page",
-            )
-        })?;
-
-    Ok(HtmlTemplate(RotationKeyPage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn restore_handler(State(state): State<AppState>) -> Result<impl IntoResponse, Response> {
-    let layout =
-        LayoutContext::new("Restore".to_string(), state.vite, "/restore").map_err(|err| {
-            tracing::error!(?err, "Error rendering out the restore page");
-            error_response(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Error rendering out the restore page",
-            )
-        })?;
-
-    Ok(HtmlTemplate(RestorePage {
-        layout_context: layout,
-    }))
-}
-
-pub async fn terms_privacy_handler(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, Response> {
-    let layout =
-        LayoutContext::new("Terms & Privacy".to_string(), state.vite, "/legal").map_err(|err| {
-            tracing::error!(?err, "Error rendering out the legal page");
-            error_response(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "Error rendering out the legal page",
-            )
-        })?;
-
-    Ok(HtmlTemplate(TermsPrivacyPage {
-        layout_context: layout,
-    }))
-}
-
-pub fn pages_handlers() -> Router<AppState> {
-    Router::new()
-        .route("/", get(index_handler))
-        .route("/moover", get(moover_handler))
-        .route("/info", get(info_handler))
-        .route("/turn-off", get(turn_off_handler))
-        .route("/missing-blobs", get(missing_blobs_handler))
-        .route("/backups", get(backups_signup_handler))
-        .route("/rotation-key", get(rotation_key_handler))
-        .route("/restore", get(restore_handler))
-        .route("/terms", get(terms_privacy_handler))
-}

web/src/main.rs

···
 mod handlers;
-mod templates;
 
-use crate::handlers::pages::pages_handlers;
 use crate::handlers::well_known::{
     ServiceDID, ServiceDocument, ServiceKey, build_service_document, handle_wellknown_did_web,
 };
···
 use crate::handlers::xrpc::com_pdsmoover_admin_handlers::admin_routes;
 use crate::handlers::xrpc::com_pdsmoover_backup_handlers::backup_routes;
 use atproto_identity::key::to_public;
-use axum::handler::HandlerWithoutStateExt;
-use axum::http::StatusCode;
-use axum::response::Redirect;
+use axum::http::header;
 use axum::{Router, routing::get};
 use chrono::{DateTime, Utc};
 use dotenvy::dotenv;
···
 use tower_governor::GovernorLayer;
 use tower_governor::governor::GovernorConfigBuilder;
 use tower_governor::key_extractor::SmartIpKeyExtractor;
-use tower_http::services::ServeDir;
+use tower_http::cors::{Any, CorsLayer};
 use tracing::info;
 use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
-use vite_rust::utils::resolve_path;
-use vite_rust::{Vite, ViteConfig};
 
 #[derive(Clone)]
 struct AppState {
     db: Db,
-    vite: Arc<Vite>,
     public_resolver: Arc<PublicResolver>,
     service_document: ServiceDocument,
     did_web: ServiceDID,
···
     let db = Db::connect(&database_url).await?;
     db.apply_migrations().await?;
 
-    //Vite setup
-    let vite_dist = std::env::var("VITE_DIST").unwrap_or_else(|_| "../ui-code/dist".to_string());
-    let manifest_path: String =
-        resolve_path(file!(), format!("{vite_dist}/.vite/manifest.json").as_str());
-    let mut vite_config: ViteConfig<'_> = ViteConfig::default().set_manifest_path(&manifest_path);
-    vite_config.entrypoints = Some(vec![
-        "src/main.js",
-        "src/pdsmoover.js",
-        "src/missingBlobs.js",
-    ]);
-    let vite = vite_rust::Vite::new(vite_config).await?;
-
-    let fallback_404_service = handle_404.into_service();
-    let dist_dir = ServeDir::new(format!("{vite_dist}/assets"))
-        .not_found_service(fallback_404_service.clone());
-    let public_dir =
-        ServeDir::new(env::var("PUBLIC_ASSETS")?).not_found_service(fallback_404_service);
-
     //did:web/atproto service setup
     let external_domain = env::var("EXTERNAL_DOMAIN")?;
     let service_key_string = env::var("SERVICE_KEY")?;
···
 
     let state = AppState {
         db,
-        vite: Arc::new(vite),
         service_document,
         public_resolver: Arc::new(resolver),
         did_web: service_did,
···
 
     // Build Axum router
     let mut app = Router::new()
+        .route("/", get(root_handler))
         //XRPC Routes
         .merge(backup_routes(state.clone()))
         .merge(atproto_routes(state.clone()))
         //Other routes
-        .merge(pages_handlers())
-        .route("/.well-known/did.json", get(handle_wellknown_did_web))
-        // Example legacy redirects
-        .route(
-            "/turnoff.html",
-            get(async move || Redirect::permanent("/turn-off")),
-        )
-        .route(
-            "/info.html",
-            get(async move || Redirect::permanent("/turn-off")),
-        );
+        .route("/.well-known/did.json", get(handle_wellknown_did_web));
 
     // Conditionally add admin endpoints only if ADMIN_PASSWORD is set
     if state.admin_token.is_some() {
···
         app = app.merge(admin_routes(state.clone()).layer(governor_layer));
     }
 
-    //catch all routes
-    app = app
-        .nest_service("/assets", dist_dir)
-        .fallback_service(public_dir);
+    //CORS
+    let cors = CorsLayer::new()
+        .allow_methods(Any)
+        .allow_origin(Any)
+        .allow_headers(Any);
 
     // Finalize with state
-    let app = app
-        // .route("/demo", post(create_demo))
-        .with_state(state);
+    let app = app.layer(cors).with_state(state);
 
     // Read PORT from env or default to 3000
     let port: u16 = std::env::var("PORT")
···
     Ok(())
 }
 
-async fn handle_404() -> (StatusCode, &'static str) {
-    (StatusCode::NOT_FOUND, "Not found")
+async fn root_handler() -> impl axum::response::IntoResponse {
+    let body = r"
+.---. .---.  .--.
+: .; :: .  :: .--'
+:  _.': :: :`. `.
+: :   : :; : _`, :
+:_;   :___.'`.__.'
+
+
+.-..-. .--.  .--.
+: `' :: ,. :: ,. :
+: .. :: :: :: :: :.-..-. .--. .--.
+: :; :: :; :: :; :: `; :' '_.': ..'
+:_;:_;`.__.'`.__.'`.__.'`.__.':_;
+
+ ";
+
+    let intro = "\n\nThis is a PDS MOOver xrpc service\n\nCode: https://tangled.sh/@baileytownsend.dev/pds-moover\n";
+
+    let banner = format!("         {body}\n{intro}");
+
+    (
+        [(header::CONTENT_TYPE, "text/plain; charset=utf-8")],
+        banner,
+    )
 }

web/src/templates.rs

···
-use askama::Template;
-use axum::http::StatusCode;
-use axum::response::{Html, IntoResponse, Response};
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use vite_rust::Vite;
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct LayoutContext {
-    pub title: String,
-    pub script_tags: String,
-    pub vite_hmr_url: Option<String>,
-    pub current_path: String,
-}
-
-impl LayoutContext {
-    pub fn new(title: String, vite: Arc<Vite>, current_path: &str) -> anyhow::Result<Self> {
-        let vite_script_tags = vite.get_resolved_vite_scripts()?;
-        let hmr = if vite.get_hmr_script() == "" {
-            None
-        } else {
-            Some(vite.get_hmr_script())
-        };
-        Ok(Self {
-            title,
-            script_tags: vite_script_tags,
-            vite_hmr_url: hmr,
-            current_path: current_path.to_string(),
-        })
-    }
-}
-
-pub fn error_response(status: StatusCode, message: &str) -> Response {
-    IntoResponse::into_response((
-        status,
-        HtmlTemplate(ErrorTemplate {
-            title: "PDS MOOver - Error",
-            message,
-        }),
-    ))
-}
-pub struct HtmlTemplate<T>(pub T);
-
-/// Allows us to convert Askama HTML templates into valid HTML
-/// for axum to serve in the response.
-impl<T> IntoResponse for HtmlTemplate<T>
-where
-    T: Template,
-{
-    fn into_response(self) -> Response {
-        // Attempt to render the template with askama
-        match self.0.render() {
-            // If we're able to successfully parse and aggregate the template, serve it
-            Ok(html) => Html(html).into_response(),
-            // If we're not, return an error or some bit of fallback HTML
-            Err(err) => {
-                log::error!("Failed to render template: {}", err);
-                IntoResponse::into_response((
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    "Failed to render the HTML Template",
-                ))
-            }
-        }
-    }
-}
-
-#[derive(Template)]
-#[template(path = "error.askama.html")]
-pub struct ErrorTemplate<'a> {
-    pub title: &'a str,
-    pub message: &'a str,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "index.askama.html")]
-pub struct IndexPage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "moover.askama.html")]
-pub struct MooverPage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "info.askama.html")]
-pub struct InfoPage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "turn-off.askama.html")]
-pub struct TurnOffPage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "missing-blobs.askama.html")]
-pub struct MissingBlobsPage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "backups.askama.html")]
-pub struct BackupsPage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-
-#[derive(Template, Debug)]
-#[template(path = "rotation-key.askama.html")]
-pub struct RotationKeyPage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "restore.askama.html")]
-pub struct RestorePage {
-    pub(crate) layout_context: LayoutContext,
-}
-
-#[derive(Template, Debug)]
-#[template(path = "terms.askama.html")]
-pub struct TermsPrivacyPage {
-    pub(crate) layout_context: LayoutContext,
-}

web/templates/backups.askama.html

···
                 showTwoFactorCodeInput: false,
                 error: null,
                 showStatusMessage: false,
-                showLoginScreen: true,
+                //The landing page to pick to login with password or oauth
+                showLandingButtons: true,
+                //Password login
+                showLoginScreen: false,
                 showRepoNotFoundScreen: false,
                 addRecoveryKey: true,
                 // Rotation key flow state
···
                         this.showStatusMessage = false;
                     }
                 },
+                handleShowLogin() {
+                    this.showLandingButtons = false;
+                    this.showLoginScreen = true;
+                },
+                async handleOAuthSignup() {
+                    // TODO: Replace this URL with your actual OAuth signup endpoint for backups
+                    // If you have an environment-specific route, consider injecting it or making it configurable
+                    window.location.href = '/oauth/backups';
+                },
                 async handleLoginSubmit() {
+                    this.error = null;
+                    this.showStatusMessage = false;
+                    this.showLandingButtons = false;
                     this.error = null;
                     this.showStatusMessage = false;
 
···
     {% call cow::cow_header("Backups") %}
 
 
-    <form id="backup-signup-form" @submit.prevent="await handleLoginSubmit()" x-show="showLoginScreen">
+    <!-- Landing choice: two buttons -->
+    <div x-show="showLoginScreen">
         <!-- Informational section before sign-in -->
         <div class="section" style="text-align: left;">
-            <p>
-            PDS MOOver can provide worry free backups of your AT Protocol account. This is a free service for individual accounts and stores the backups on PDS MOOver's servers. Just like your  <a target="_blank" rel="noopener noreferrer"  href="https://blueskyweb.zendesk.com/hc/en-us/articles/15835264007693-Data-Privacy">AT Proto data</a>, this is also public. On login, you will be asked if you'd like to add a rotation key to your account.
-            A rotation key is a recovery key that allows you to restore your account if your PDS ever goes down. If you're already signed up for backups, then you can log in here to manage them.
-            </p>
+             <p>
+                  PDS MOOver can provide worry-free backups of your AT Protocol account.
+                   This is a free service for individual accounts
+                   and stores the backups on PDS MOOver's servers.
+                   Just like your <a target="_blank" rel="noopener noreferrer" href="https://blueskyweb.zendesk.com/hc/en-us/articles/15835264007693-Data-Privacy">AT Proto data</a>,
+                   this is also public.
+                <span x-show="showLoginScreen">On login,
+                   you will be asked if you'd like to add a rotation key to your account.
+                                                                                     A rotation key is a recovery key
+                                                                                     that allows you to restore your account if your PDS ever goes down.
+                                                                                     If you're already signed up for backups, then you can log in here to manage them.</span>
+
+              </p>
         </div>
-        <!-- Sign-in section -->
-        <div class="section">
-            <h2>Sign in to your account</h2>
-            <div class="form-group">
-                <label for="handle">Handle</label>
-                <input type="text" id="handle" name="handle" placeholder="alice.bsky.social" x-model="handle" required>
-            </div>
 
-            <div class="form-group">
-                <label for="password">Real Password</label>
-                <input type="password" id="password" name="password" x-model="password" required>
-            <p> If you are signing up and adding a rotation key you have to use your account's real password. If you are just managing your backups or have your own rotation key you can use an app password</p>
+       <div x-show="showLandingButtons" class="actions" style="display: flex; gap: 1rem; flex-wrap: wrap;">
+            <button type="button" @click="handleShowLogin()">Sign in to add a recovery key</button>
+            <button type="button" @click="await handleOAuthSignup()">Sign in for backups with OAuth</button>
+        </div>
+
+        <!-- Sign in with password section -->
+        <form id="backup-signup-form" @submit.prevent="await handleLoginSubmit()">
+
+            <div class="section">
+                <h2>Sign in to your account</h2>
+                <div class="form-group">
+                    <label for="handle">Handle</label>
+                    <input type="text" id="handle" name="handle" placeholder="alice.bsky.social" x-model="handle" required>
+                </div>
+
+                <div class="form-group">
+                    <label for="password">Real Password</label>
+                    <input type="password" id="password" name="password" x-model="password" required>
+                <p> If you are signing up and adding a rotation key you have to use your account's real password. If you are just managing your backups or have your own rotation key you can use an app password</p>
+
+                </div>
 
+                <div x-show="showTwoFactorCodeInput" class="form-group">
+                    <label for="two-factor-code">Two-factor code (email)</label>
+                    <input type="text" id="two-factor-code" name="two-factor-code" x-model="twoFactorCode">
+                    <div class="error-message">Enter the 2FA code from your email.</div>
+                </div>
             </div>
 
-            <div x-show="showTwoFactorCodeInput" class="form-group">
-                <label for="two-factor-code">Two-factor code (email)</label>
-                <input type="text" id="two-factor-code" name="two-factor-code" x-model="twoFactorCode">
-                <div class="error-message">Enter the 2FA code from your email.</div>
+            <div x-show="error" x-text="error" class="error-message"></div>
+            <div x-show="showStatusMessage" id="status-message" class="status-message"></div>
+            <div>
+                <button type="submit">Login for backups</button>
             </div>
-        </div>
-
-        <div x-show="error" x-text="error" class="error-message"></div>
-        <div x-show="showStatusMessage" id="status-message" class="status-message"></div>
-        <div>
-            <button type="submit">Login for backups</button>
-        </div>
-    </form>
+        </form>
+    </div>
 
     <!-- Repo not found prompt -->
     <div class="section" x-show="showRepoNotFoundScreen">
···
     </template>
 
     <!-- Repo status view for signed-up users -->
-    <div class="section" x-show="!showLoginScreen && !showRepoNotFoundScreen && !showRotationKeyScreen">
+    <div class="section" x-show="!showLandingButtons && !showLoginScreen && !showRepoNotFoundScreen && !showRotationKeyScreen">
         <div class="section-header">
             <h2 style="margin: 0;">Backup repository status</h2>
             <button type="button" class="icon-button" title="Refresh status" aria-label="Refresh status" @click="refreshStatus">

web/templates/index.askama.html

···
       }
     },
     //TODO bad but do not want to figure out onload with current setup
-    fmtBytes(bytes) {
-      if (bytes == null) return '—';
-      const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-      let i = 0;
-      let v = Number(bytes);
-      while (v >= 1024 && i < units.length - 1) {
-        v /= 1024;
-        i++;
-      }
-      return v.toFixed(1) + ' ' + units[i];
-    },
-    fmtDate(value) {
-      if (!value) return '—';
-      try {
-        const d = new Date(value);
-        return d.toLocaleString();
-      } catch (_) {
-        return String(value);
-      }
-    }
+
 
   }));
 });

web/templates/moover.askama.html

···
             <button type="submit">MOOve</button>
         </div>
     </form>
+
     <div x-show="askForPlcToken" class="section">
         <form @submit.prevent="await signPlcOperation()">
             <div x-show="!done">

web/ui-code/bun.lock packages/moover/bun.lock

···
   "lockfileVersion": 1,
   "workspaces": {
     "": {
-      "name": "ui-code",
+      "name": "moover",
       "dependencies": {
+        "@atcute/cbor": "^2.2.7",
+        "@atcute/client": "^4.0.4",
+        "@atcute/crypto": "^2.2.5",
+        "@atcute/did-plc": "^0.1.7",
         "@atcute/identity-resolver": "^1.1.3",
+        "@atcute/lexicons": "^1.2.2",
+        "@atcute/multibase": "^1.1.6",
         "@atproto/api": "^0.16.7",
+        "@pds-moover/lexicons": "^1.0.0",
+        "alpinejs": "^3.15.0",
         "vite-plugin-full-reload": "^1.2.0",
         "vite-rs-plugin": "1.0.1",
       },
···
     },
   },
   "packages": {
+    "@atcute/cbor": ["@atcute/cbor@2.2.7", "", { "dependencies": { "@atcute/cid": "^2.2.5", "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5" } }, "sha512-/mwAF0gnokOphceZqFq3uzMGdd8sbw5y6bxF8CRutRkCCUcpjjpJc5fkLwhxyGgOveF3mZuHE6p7t/+IAqb7Aw=="],
+
+    "@atcute/cid": ["@atcute/cid@2.2.6", "", { "dependencies": { "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5" } }, "sha512-bTAHHbJ24p+E//V4KCS4xdmd39o211jJswvqQOevj7vk+5IYcgDLx1ryZWZ1sEPOo9x875li/kj5gpKL14RDwQ=="],
+
+    "@atcute/client": ["@atcute/client@4.0.5", "", { "dependencies": { "@atcute/identity": "^1.1.1", "@atcute/lexicons": "^1.2.2" } }, "sha512-R8Qen8goGmEkynYGg2m6XFlVmz0GTDvQ+9w+4QqOob+XMk8/WDpF4aImev7WKEde/rV2gjcqW7zM8E6W9NShDA=="],
+
+    "@atcute/crypto": ["@atcute/crypto@2.2.5", "", { "dependencies": { "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5", "@noble/secp256k1": "^2.3.0" } }, "sha512-9CbQ9cJ68XewsbLrgdmWQS2uDD9D0hizWFJ3OOZ16TCuARREmzKEpFgHlMxPswR3bDxjwfiXzmYUlHaTqsnxRQ=="],
+
+    "@atcute/did-plc": ["@atcute/did-plc@0.1.7", "", { "dependencies": { "@atcute/cbor": "^2.2.6", "@atcute/cid": "^2.2.4", "@atcute/crypto": "^2.2.5", "@atcute/identity": "^1.1.1", "@atcute/lexicons": "^1.2.2", "@atcute/multibase": "^1.1.6", "@atcute/uint8array": "^1.0.5", "@badrap/valita": "^0.4.6" } }, "sha512-a7yOQNqViae3rB5/xa3U0EPJbFD9l8zOHXx6XASZ5F8+Vy2uTgXK3omurpNZ5UxRpy1ni1AMhSohXr61cqWbkg=="],
+
     "@atcute/identity": ["@atcute/identity@1.1.1", "", { "dependencies": { "@atcute/lexicons": "^1.2.2", "@badrap/valita": "^0.4.6" } }, "sha512-zax42n693VEhnC+5tndvO2KLDTMkHOz8UExwmklvJv7R9VujfEwiSWhcv6Jgwb3ellaG8wjiQ1lMOIjLLvwh0Q=="],
 
     "@atcute/identity-resolver": ["@atcute/identity-resolver@1.1.4", "", { "dependencies": { "@atcute/lexicons": "^1.2.2", "@atcute/util-fetch": "^1.0.3", "@badrap/valita": "^0.4.6" }, "peerDependencies": { "@atcute/identity": "^1.0.0" } }, "sha512-/SVh8vf2cXFJenmBnGeYF2aY3WGQm3cJeew5NWTlkqoy3LvJ5wkvKq9PWu4Tv653VF40rPOp6LOdVr9Fa+q5rA=="],
 
     "@atcute/lexicons": ["@atcute/lexicons@1.2.2", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "esm-env": "^1.2.2" } }, "sha512-bgEhJq5Z70/0TbK5sx+tAkrR8FsCODNiL2gUEvS5PuJfPxmFmRYNWaMGehxSPaXWpU2+Oa9ckceHiYbrItDTkA=="],
+
+    "@atcute/multibase": ["@atcute/multibase@1.1.6", "", { "dependencies": { "@atcute/uint8array": "^1.0.5" } }, "sha512-HBxuCgYLKPPxETV0Rot4VP9e24vKl8JdzGCZOVsDaOXJgbRZoRIF67Lp0H/OgnJeH/Xpva8Z5ReoTNJE5dn3kg=="],
+
+    "@atcute/uint8array": ["@atcute/uint8array@1.0.5", "", {}, "sha512-XLWWxoR2HNl2qU+FCr0rp1APwJXci7HnzbOQLxK55OaMNBXZ19+xNC5ii4QCsThsDxa4JS/JTzuiQLziITWf2Q=="],
 
     "@atcute/util-fetch": ["@atcute/util-fetch@1.0.3", "", { "dependencies": { "@badrap/valita": "^0.4.6" } }, "sha512-f8zzTb/xlKIwv2OQ31DhShPUNCmIIleX6p7qIXwWwEUjX6x8skUtpdISSjnImq01LXpltGV5y8yhV4/Mlb7CRQ=="],
 
···
 
     "@badrap/valita": ["@badrap/valita@0.4.6", "", {}, "sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg=="],
 
-    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.10", "", { "os": "aix", "cpu": "ppc64" }, "sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw=="],
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.11", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg=="],
 
-    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.10", "", { "os": "android", "cpu": "arm" }, "sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w=="],
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.11", "", { "os": "android", "cpu": "arm" }, "sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg=="],
 
-    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.10", "", { "os": "android", "cpu": "arm64" }, "sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg=="],
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.11", "", { "os": "android", "cpu": "arm64" }, "sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ=="],
 
-    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.10", "", { "os": "android", "cpu": "x64" }, "sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg=="],
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.11", "", { "os": "android", "cpu": "x64" }, "sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g=="],
 
-    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA=="],
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.11", "", { "os": "darwin", "cpu": "arm64" }, "sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w=="],
 
-    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg=="],
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.11", "", { "os": "darwin", "cpu": "x64" }, "sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ=="],
 
-    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.10", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg=="],
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.11", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA=="],
 
-    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.10", "", { "os": "freebsd", "cpu": "x64" }, "sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA=="],
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.11", "", { "os": "freebsd", "cpu": "x64" }, "sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw=="],
 
-    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.10", "", { "os": "linux", "cpu": "arm" }, "sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg=="],
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.11", "", { "os": "linux", "cpu": "arm" }, "sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw=="],
 
-    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ=="],
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA=="],
 
-    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.10", "", { "os": "linux", "cpu": "ia32" }, "sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ=="],
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.11", "", { "os": "linux", "cpu": "ia32" }, "sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw=="],
 
-    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.10", "", { "os": "linux", "cpu": "none" }, "sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg=="],
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw=="],
 
-    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.10", "", { "os": "linux", "cpu": "none" }, "sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA=="],
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ=="],
 
-    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.10", "", { "os": "linux", "cpu": "ppc64" }, "sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA=="],
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.11", "", { "os": "linux", "cpu": "ppc64" }, "sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw=="],
 
-    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.10", "", { "os": "linux", "cpu": "none" }, "sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA=="],
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww=="],
 
-    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.10", "", { "os": "linux", "cpu": "s390x" }, "sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew=="],
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.11", "", { "os": "linux", "cpu": "s390x" }, "sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw=="],
 
-    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.10", "", { "os": "linux", "cpu": "x64" }, "sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA=="],
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.11", "", { "os": "linux", "cpu": "x64" }, "sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ=="],
 
-    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.10", "", { "os": "none", "cpu": "arm64" }, "sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A=="],
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.11", "", { "os": "none", "cpu": "arm64" }, "sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg=="],
 
-    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.10", "", { "os": "none", "cpu": "x64" }, "sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig=="],
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.11", "", { "os": "none", "cpu": "x64" }, "sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A=="],
 
-    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.10", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw=="],
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.11", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg=="],
 
-    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.10", "", { "os": "openbsd", "cpu": "x64" }, "sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw=="],
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.11", "", { "os": "openbsd", "cpu": "x64" }, "sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw=="],
 
-    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.10", "", { "os": "none", "cpu": "arm64" }, "sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag=="],
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.11", "", { "os": "none", "cpu": "arm64" }, "sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ=="],
 
-    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.10", "", { "os": "sunos", "cpu": "x64" }, "sha512-fswk3XT0Uf2pGJmOpDB7yknqhVkJQkAQOcW/ccVOtfx05LkbWOaRAtn5SaqXypeKQra1QaEa841PgrSL9ubSPQ=="],
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.11", "", { "os": "sunos", "cpu": "x64" }, "sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA=="],
 
-    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.10", "", { "os": "win32", "cpu": "arm64" }, "sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw=="],
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.11", "", { "os": "win32", "cpu": "arm64" }, "sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q=="],
 
-    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.10", "", { "os": "win32", "cpu": "ia32" }, "sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw=="],
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.11", "", { "os": "win32", "cpu": "ia32" }, "sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA=="],
 
-    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.10", "", { "os": "win32", "cpu": "x64" }, "sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw=="],
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.11", "", { "os": "win32", "cpu": "x64" }, "sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA=="],
 
     "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.9.0", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g=="],
 
-    "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.1", "", {}, "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ=="],
+    "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.2", "", {}, "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew=="],
 
-    "@eslint/config-array": ["@eslint/config-array@0.21.0", "", { "dependencies": { "@eslint/object-schema": "^2.1.6", "debug": "^4.3.1", "minimatch": "^3.1.2" } }, "sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ=="],
+    "@eslint/config-array": ["@eslint/config-array@0.21.1", "", { "dependencies": { "@eslint/object-schema": "^2.1.7", "debug": "^4.3.1", "minimatch": "^3.1.2" } }, "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA=="],
 
-    "@eslint/config-helpers": ["@eslint/config-helpers@0.4.0", "", { "dependencies": { "@eslint/core": "^0.16.0" } }, "sha512-WUFvV4WoIwW8Bv0KeKCIIEgdSiFOsulyN0xrMu+7z43q/hkOLXjvb5u7UC9jDxvRzcrbEmuZBX5yJZz1741jog=="],
+    "@eslint/config-helpers": ["@eslint/config-helpers@0.4.1", "", { "dependencies": { "@eslint/core": "^0.16.0" } }, "sha512-csZAzkNhsgwb0I/UAV6/RGFTbiakPCf0ZrGmrIxQpYvGZ00PhTkSnyKNolphgIvmnJeGw6rcGVEXfTzUnFuEvw=="],
 
     "@eslint/core": ["@eslint/core@0.16.0", "", { "dependencies": { "@types/json-schema": "^7.0.15" } }, "sha512-nmC8/totwobIiFcGkDza3GIKfAw1+hLiYVrh3I1nIomQ8PEr5cxg34jnkmGawul/ep52wGRAcyeDCNtWKSOj4Q=="],
 
     "@eslint/eslintrc": ["@eslint/eslintrc@3.3.1", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^10.0.1", "globals": "^14.0.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ=="],
 
-    "@eslint/js": ["@eslint/js@9.37.0", "", {}, "sha512-jaS+NJ+hximswBG6pjNX0uEJZkrT0zwpVi3BA3vX22aFGjJjmgSTSmPpZCRKmoBL5VY/M6p0xsSJx7rk7sy5gg=="],
+    "@eslint/js": ["@eslint/js@9.38.0", "", {}, "sha512-UZ1VpFvXf9J06YG9xQBdnzU+kthors6KjhMAl6f4gH4usHyh31rUf2DLGInT8RFYIReYXNSydgPY0V2LuWgl7A=="],
 
-    "@eslint/object-schema": ["@eslint/object-schema@2.1.6", "", {}, "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA=="],
+    "@eslint/object-schema": ["@eslint/object-schema@2.1.7", "", {}, "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA=="],
 
     "@eslint/plugin-kit": ["@eslint/plugin-kit@0.4.0", "", { "dependencies": { "@eslint/core": "^0.16.0", "levn": "^0.4.1" } }, "sha512-sB5uyeq+dwCWyPi31B2gQlVlo+j5brPlWx4yZBrEaRo/nhdDE8Xke1gsGgtiBdaBTxuTkceLVuVt/pclrasb0A=="],
 
···
 
     "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="],
 
-    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.52.4", "", { "os": "android", "cpu": "arm" }, "sha512-BTm2qKNnWIQ5auf4deoetINJm2JzvihvGb9R6K/ETwKLql/Bb3Eg2H1FBp1gUb4YGbydMA3jcmQTR73q7J+GAA=="],
+    "@noble/secp256k1": ["@noble/secp256k1@2.3.0", "", {}, "sha512-0TQed2gcBbIrh7Ccyw+y/uZQvbJwm7Ao4scBUxqpBCcsOlZG0O4KGfjtNAy/li4W8n1xt3dxrwJ0beZ2h2G6Kw=="],
 
-    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.52.4", "", { "os": "android", "cpu": "arm64" }, "sha512-P9LDQiC5vpgGFgz7GSM6dKPCiqR3XYN1WwJKA4/BUVDjHpYsf3iBEmVz62uyq20NGYbiGPR5cNHI7T1HqxNs2w=="],
+    "@pds-moover/lexicons": ["@pds-moover/lexicons@1.0.0", "", { "dependencies": { "@atproto/lexicon": "^0.5.1", "@atproto/xrpc": "^0.7.5" } }, "sha512-1/q4ZUf0PuyDTLuyuGunsBvQBo1+V8W80/QAw7VHqO6Uvu/+VjcriM2C7O4F7Q+KFX3QPFEiK0vRSyaSdgg5Zw=="],
 
-    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.52.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-QRWSW+bVccAvZF6cbNZBJwAehmvG9NwfWHwMy4GbWi/BQIA/laTIktebT2ipVjNncqE6GLPxOok5hsECgAxGZg=="],
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.52.5", "", { "os": "android", "cpu": "arm" }, "sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ=="],
 
-    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.52.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-hZgP05pResAkRJxL1b+7yxCnXPGsXU0fG9Yfd6dUaoGk+FhdPKCJ5L1Sumyxn8kvw8Qi5PvQ8ulenUbRjzeCTw=="],
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.52.5", "", { "os": "android", "cpu": "arm64" }, "sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA=="],
 
-    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.52.4", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-xmc30VshuBNUd58Xk4TKAEcRZHaXlV+tCxIXELiE9sQuK3kG8ZFgSPi57UBJt8/ogfhAF5Oz4ZSUBN77weM+mQ=="],
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.52.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA=="],
 
-    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.52.4", "", { "os": "freebsd", "cpu": "x64" }, "sha512-WdSLpZFjOEqNZGmHflxyifolwAiZmDQzuOzIq9L27ButpCVpD7KzTRtEG1I0wMPFyiyUdOO+4t8GvrnBLQSwpw=="],
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.52.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA=="],
 
-    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.52.4", "", { "os": "linux", "cpu": "arm" }, "sha512-xRiOu9Of1FZ4SxVbB0iEDXc4ddIcjCv2aj03dmW8UrZIW7aIQ9jVJdLBIhxBI+MaTnGAKyvMwPwQnoOEvP7FgQ=="],
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.52.5", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA=="],
 
-    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.52.4", "", { "os": "linux", "cpu": "arm" }, "sha512-FbhM2p9TJAmEIEhIgzR4soUcsW49e9veAQCziwbR+XWB2zqJ12b4i/+hel9yLiD8pLncDH4fKIPIbt5238341Q=="],
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.52.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ=="],
 
-    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.52.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-4n4gVwhPHR9q/g8lKCyz0yuaD0MvDf7dV4f9tHt0C73Mp8h38UCtSCSE6R9iBlTbXlmA8CjpsZoujhszefqueg=="],
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.52.5", "", { "os": "linux", "cpu": "arm" }, "sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ=="],
 
-    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.52.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-u0n17nGA0nvi/11gcZKsjkLj1QIpAuPFQbR48Subo7SmZJnGxDpspyw2kbpuoQnyK+9pwf3pAoEXerJs/8Mi9g=="],
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.52.5", "", { "os": "linux", "cpu": "arm" }, "sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ=="],
 
-    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.52.4", "", { "os": "linux", "cpu": "none" }, "sha512-0G2c2lpYtbTuXo8KEJkDkClE/+/2AFPdPAbmaHoE870foRFs4pBrDehilMcrSScrN/fB/1HTaWO4bqw+ewBzMQ=="],
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.52.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg=="],
 
-    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.52.4", "", { "os": "linux", "cpu": "ppc64" }, "sha512-teSACug1GyZHmPDv14VNbvZFX779UqWTsd7KtTM9JIZRDI5NUwYSIS30kzI8m06gOPB//jtpqlhmraQ68b5X2g=="],
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.52.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q=="],
 
-    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.52.4", "", { "os": "linux", "cpu": "none" }, "sha512-/MOEW3aHjjs1p4Pw1Xk4+3egRevx8Ji9N6HUIA1Ifh8Q+cg9dremvFCUbOX2Zebz80BwJIgCBUemjqhU5XI5Eg=="],
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.52.5", "", { "os": "linux", "cpu": "none" }, "sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA=="],
 
-    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.52.4", "", { "os": "linux", "cpu": "none" }, "sha512-1HHmsRyh845QDpEWzOFtMCph5Ts+9+yllCrREuBR/vg2RogAQGGBRC8lDPrPOMnrdOJ+mt1WLMOC2Kao/UwcvA=="],
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.52.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw=="],
 
-    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.52.4", "", { "os": "linux", "cpu": "s390x" }, "sha512-seoeZp4L/6D1MUyjWkOMRU6/iLmCU2EjbMTyAG4oIOs1/I82Y5lTeaxW0KBfkUdHAWN7j25bpkt0rjnOgAcQcA=="],
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.52.5", "", { "os": "linux", "cpu": "none" }, "sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw=="],
 
-    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.52.4", "", { "os": "linux", "cpu": "x64" }, "sha512-Wi6AXf0k0L7E2gteNsNHUs7UMwCIhsCTs6+tqQ5GPwVRWMaflqGec4Sd8n6+FNFDw9vGcReqk2KzBDhCa1DLYg=="],
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.52.5", "", { "os": "linux", "cpu": "none" }, "sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg=="],
 
-    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.52.4", "", { "os": "linux", "cpu": "x64" }, "sha512-dtBZYjDmCQ9hW+WgEkaffvRRCKm767wWhxsFW3Lw86VXz/uJRuD438/XvbZT//B96Vs8oTA8Q4A0AfHbrxP9zw=="],
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.52.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ=="],
 
-    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.52.4", "", { "os": "none", "cpu": "arm64" }, "sha512-1ox+GqgRWqaB1RnyZXL8PD6E5f7YyRUJYnCqKpNzxzP0TkaUh112NDrR9Tt+C8rJ4x5G9Mk8PQR3o7Ku2RKqKA=="],
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.52.5", "", { "os": "linux", "cpu": "x64" }, "sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q=="],
 
-    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.52.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-8GKr640PdFNXwzIE0IrkMWUNUomILLkfeHjXBi/nUvFlpZP+FA8BKGKpacjW6OUUHaNI6sUURxR2U2g78FOHWQ=="],
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.52.5", "", { "os": "linux", "cpu": "x64" }, "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg=="],
 
-    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.52.4", "", { "os": "win32", "cpu": "ia32" }, "sha512-AIy/jdJ7WtJ/F6EcfOb2GjR9UweO0n43jNObQMb6oGxkYTfLcnN7vYYpG+CN3lLxrQkzWnMOoNSHTW54pgbVxw=="],
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.52.5", "", { "os": "none", "cpu": "arm64" }, "sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw=="],
 
-    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.52.4", "", { "os": "win32", "cpu": "x64" }, "sha512-UF9KfsH9yEam0UjTwAgdK0anlQ7c8/pWPU2yVjyWcF1I1thABt6WXE47cI71pGiZ8wGvxohBoLnxM04L/wj8mQ=="],
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.52.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w=="],
 
-    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.52.4", "", { "os": "win32", "cpu": "x64" }, "sha512-bf9PtUa0u8IXDVxzRToFQKsNCRz9qLYfR/MpECxl4mRoWYjAeFjgxj1XdZr2M/GNVpT05p+LgQOHopYDlUu6/w=="],
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.52.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.52.5", "", { "os": "win32", "cpu": "x64" }, "sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.52.5", "", { "os": "win32", "cpu": "x64" }, "sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg=="],
 
     "@rtsao/scc": ["@rtsao/scc@1.1.0", "", {}, "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g=="],
 
···
 
     "@types/json5": ["@types/json5@0.0.29", "", {}, "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ=="],
 
+    "@vue/reactivity": ["@vue/reactivity@3.1.5", "", { "dependencies": { "@vue/shared": "3.1.5" } }, "sha512-1tdfLmNjWG6t/CsPldh+foumYFo3cpyCHgBYQ34ylaMsJ+SNHQ1kApMIa8jN+i593zQuaw3AdWH0nJTARzCFhg=="],
+
+    "@vue/shared": ["@vue/shared@3.1.5", "", {}, "sha512-oJ4F3TnvpXaQwZJNF3ZK+kLPHKarDmJjJ6jyzVNDKH9md1dptjC7lWR//jrGuLdek/U6iltWxqAnYOu8gCiOvA=="],
+
     "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
     "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
 
     "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="],
+
+    "alpinejs": ["alpinejs@3.15.1", "", { "dependencies": { "@vue/reactivity": "~3.1.1" } }, "sha512-HLO1TtiE92VajFHtLLPK8BWaK1YepV/uj31UrfoGnQ00lyFOJZ+oVY3F0DghPAwvg8sLU79pmjGQSytERa2gEg=="],
 
     "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
 
···
 
     "es-to-primitive": ["es-to-primitive@1.3.0", "", { "dependencies": { "is-callable": "^1.2.7", "is-date-object": "^1.0.5", "is-symbol": "^1.0.4" } }, "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g=="],
 
-    "esbuild": ["esbuild@0.25.10", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.10", "@esbuild/android-arm": "0.25.10", "@esbuild/android-arm64": "0.25.10", "@esbuild/android-x64": "0.25.10", "@esbuild/darwin-arm64": "0.25.10", "@esbuild/darwin-x64": "0.25.10", "@esbuild/freebsd-arm64": "0.25.10", "@esbuild/freebsd-x64": "0.25.10", "@esbuild/linux-arm": "0.25.10", "@esbuild/linux-arm64": "0.25.10", "@esbuild/linux-ia32": "0.25.10", "@esbuild/linux-loong64": "0.25.10", "@esbuild/linux-mips64el": "0.25.10", "@esbuild/linux-ppc64": "0.25.10", "@esbuild/linux-riscv64": "0.25.10", "@esbuild/linux-s390x": "0.25.10", "@esbuild/linux-x64": "0.25.10", "@esbuild/netbsd-arm64": "0.25.10", "@esbuild/netbsd-x64": "0.25.10", "@esbuild/openbsd-arm64": "0.25.10", "@esbuild/openbsd-x64": "0.25.10", "@esbuild/openharmony-arm64": "0.25.10", "@esbuild/sunos-x64": "0.25.10", "@esbuild/win32-arm64": "0.25.10", "@esbuild/win32-ia32": "0.25.10", "@esbuild/win32-x64": "0.25.10" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ=="],
+    "esbuild": ["esbuild@0.25.11", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.11", "@esbuild/android-arm": "0.25.11", "@esbuild/android-arm64": "0.25.11", "@esbuild/android-x64": "0.25.11", "@esbuild/darwin-arm64": "0.25.11", "@esbuild/darwin-x64": "0.25.11", "@esbuild/freebsd-arm64": "0.25.11", "@esbuild/freebsd-x64": "0.25.11", "@esbuild/linux-arm": "0.25.11", "@esbuild/linux-arm64": "0.25.11", "@esbuild/linux-ia32": "0.25.11", "@esbuild/linux-loong64": "0.25.11", "@esbuild/linux-mips64el": "0.25.11", "@esbuild/linux-ppc64": "0.25.11", "@esbuild/linux-riscv64": "0.25.11", "@esbuild/linux-s390x": "0.25.11", "@esbuild/linux-x64": "0.25.11", "@esbuild/netbsd-arm64": "0.25.11", "@esbuild/netbsd-x64": "0.25.11", "@esbuild/openbsd-arm64": "0.25.11", "@esbuild/openbsd-x64": "0.25.11", "@esbuild/openharmony-arm64": "0.25.11", "@esbuild/sunos-x64": "0.25.11", "@esbuild/win32-arm64": "0.25.11", "@esbuild/win32-ia32": "0.25.11", "@esbuild/win32-x64": "0.25.11" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q=="],
 
     "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
 
-    "eslint": ["eslint@9.37.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", "@eslint/config-array": "^0.21.0", "@eslint/config-helpers": "^0.4.0", "@eslint/core": "^0.16.0", "@eslint/eslintrc": "^3.3.1", "@eslint/js": "9.37.0", "@eslint/plugin-kit": "^0.4.0", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "@types/json-schema": "^7.0.15", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^8.4.0", "eslint-visitor-keys": "^4.2.1", "espree": "^10.4.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-XyLmROnACWqSxiGYArdef1fItQd47weqB7iwtfr9JHwRrqIXZdcFMvvEcL9xHCmL0SNsOvF0c42lWyM1U5dgig=="],
+    "eslint": ["eslint@9.38.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", "@eslint/config-array": "^0.21.1", "@eslint/config-helpers": "^0.4.1", "@eslint/core": "^0.16.0", "@eslint/eslintrc": "^3.3.1", "@eslint/js": "9.38.0", "@eslint/plugin-kit": "^0.4.0", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^8.4.0", "eslint-visitor-keys": "^4.2.1", "espree": "^10.4.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-t5aPOpmtJcZcz5UJyY2GbvpDlsK5E8JqRqoKtfiKE3cNh437KIqfJr3A3AKf5k64NPx6d0G3dno6XDY05PqPtw=="],
 
     "eslint-import-resolver-node": ["eslint-import-resolver-node@0.3.9", "", { "dependencies": { "debug": "^3.2.7", "is-core-module": "^2.13.0", "resolve": "^1.22.4" } }, "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g=="],
 
···
 
     "regexp.prototype.flags": ["regexp.prototype.flags@1.5.4", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-errors": "^1.3.0", "get-proto": "^1.0.1", "gopd": "^1.2.0", "set-function-name": "^2.0.2" } }, "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA=="],
 
-    "resolve": ["resolve@1.22.10", "", { "dependencies": { "is-core-module": "^2.16.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w=="],
+    "resolve": ["resolve@1.22.11", "", { "dependencies": { "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ=="],
 
     "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
 
-    "rollup": ["rollup@4.52.4", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.52.4", "@rollup/rollup-android-arm64": "4.52.4", "@rollup/rollup-darwin-arm64": "4.52.4", "@rollup/rollup-darwin-x64": "4.52.4", "@rollup/rollup-freebsd-arm64": "4.52.4", "@rollup/rollup-freebsd-x64": "4.52.4", "@rollup/rollup-linux-arm-gnueabihf": "4.52.4", "@rollup/rollup-linux-arm-musleabihf": "4.52.4", "@rollup/rollup-linux-arm64-gnu": "4.52.4", "@rollup/rollup-linux-arm64-musl": "4.52.4", "@rollup/rollup-linux-loong64-gnu": "4.52.4", "@rollup/rollup-linux-ppc64-gnu": "4.52.4", "@rollup/rollup-linux-riscv64-gnu": "4.52.4", "@rollup/rollup-linux-riscv64-musl": "4.52.4", "@rollup/rollup-linux-s390x-gnu": "4.52.4", "@rollup/rollup-linux-x64-gnu": "4.52.4", "@rollup/rollup-linux-x64-musl": "4.52.4", "@rollup/rollup-openharmony-arm64": "4.52.4", "@rollup/rollup-win32-arm64-msvc": "4.52.4", "@rollup/rollup-win32-ia32-msvc": "4.52.4", "@rollup/rollup-win32-x64-gnu": "4.52.4", "@rollup/rollup-win32-x64-msvc": "4.52.4", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-CLEVl+MnPAiKh5pl4dEWSyMTpuflgNQiLGhMv8ezD5W/qP8AKvmYpCOKRRNOh7oRKnauBZ4SyeYkMS+1VSyKwQ=="],
+    "rollup": ["rollup@4.52.5", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.52.5", "@rollup/rollup-android-arm64": "4.52.5", "@rollup/rollup-darwin-arm64": "4.52.5", "@rollup/rollup-darwin-x64": "4.52.5", "@rollup/rollup-freebsd-arm64": "4.52.5", "@rollup/rollup-freebsd-x64": "4.52.5", "@rollup/rollup-linux-arm-gnueabihf": "4.52.5", "@rollup/rollup-linux-arm-musleabihf": "4.52.5", "@rollup/rollup-linux-arm64-gnu": "4.52.5", "@rollup/rollup-linux-arm64-musl": "4.52.5", "@rollup/rollup-linux-loong64-gnu": "4.52.5", "@rollup/rollup-linux-ppc64-gnu": "4.52.5", "@rollup/rollup-linux-riscv64-gnu": "4.52.5", "@rollup/rollup-linux-riscv64-musl": "4.52.5", "@rollup/rollup-linux-s390x-gnu": "4.52.5", "@rollup/rollup-linux-x64-gnu": "4.52.5", "@rollup/rollup-linux-x64-musl": "4.52.5", "@rollup/rollup-openharmony-arm64": "4.52.5", "@rollup/rollup-win32-arm64-msvc": "4.52.5", "@rollup/rollup-win32-ia32-msvc": "4.52.5", "@rollup/rollup-win32-x64-gnu": "4.52.5", "@rollup/rollup-win32-x64-msvc": "4.52.5", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw=="],
 
     "safe-array-concat": ["safe-array-concat@1.1.3", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "has-symbols": "^1.1.0", "isarray": "^2.0.5" } }, "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q=="],
 
···
 
     "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="],
 
-    "tlds": ["tlds@1.260.0", "", { "bin": { "tlds": "bin.js" } }, "sha512-78+28EWBhCEE7qlyaHA9OR3IPvbCLiDh3Ckla593TksfFc9vfTsgvH7eS+dr3o9qr31gwGbogcI16yN91PoRjQ=="],
+    "tlds": ["tlds@1.261.0", "", { "bin": { "tlds": "bin.js" } }, "sha512-QXqwfEl9ddlGBaRFXIvNKK6OhipSiLXuRuLJX5DErz0o0Q0rYxulWLdFryTkV5PkdZct5iMInwYEGe/eR++1AA=="],
 
     "tsconfig-paths": ["tsconfig-paths@3.15.0", "", { "dependencies": { "@types/json5": "^0.0.29", "json5": "^1.0.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } }, "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg=="],
 
···
 
     "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
 
-    "vite": ["vite@7.1.9", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-4nVGliEpxmhCL8DslSAUdxlB6+SMrhB0a1v5ijlh1xB1nEPuy1mxaHxysVucLHuWryAxLWg6a5ei+U4TLn/rFg=="],
+    "vite": ["vite@7.1.12", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-ZWyE8YXEXqJrrSLvYgrRP7p62OziLW7xI5HYGWFzOvupfAlrLvURSzv/FyGyy0eidogEM3ujU+kUG1zuHgb6Ug=="],
 
     "vite-plugin-full-reload": ["vite-plugin-full-reload@1.2.0", "", { "dependencies": { "picocolors": "^1.0.0", "picomatch": "^2.3.1" } }, "sha512-kz18NW79x0IHbxRSHm0jttP4zoO9P9gXh+n6UTwlNKnviTTEpOlum6oS9SmecrTtSr+muHEn5TUuC75UovQzcA=="],
 

web/ui-code/eslint.config.js

···
-export default [
-    {
-        ignores: ['node_modules/**', 'dist/**']
-    },
-    {
-        languageOptions: {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            globals: {
-                document: 'readonly',
-                navigator: 'readonly',
-                window: 'readonly',
-                console: 'readonly'
-            }
-        },
-        linterOptions: {
-            reportUnusedDisableDirectives: true
-        },
-        rules: {
-            'semi': ['error', 'always'],
-            'quotes': ['error', 'single'],
-            'indent': ['error', 2],
-            'no-unused-vars': 'warn'
-        }
-    }
-];

web/ui-code/index.html

···
-<!doctype html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8"/>
-    <link rel="icon" type="image/svg+xml" href="/vite.svg"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-    <title>ui-code</title>
-</head>
-<body>
-<div id="app"></div>
-<!--<script type="module" src="/src/plc-ops.js">-->
-
-
-<script type="module">
-    import {PlcOps} from './src/plc-ops.js';
-
-    const plcOps = new PlcOps();
-
-    window.runTest = async () => plcOps.test('did:plc:uc7pehijmk5jrllip4cglxdd');
-</script>
-
-<button onclick="window.runTest()">Run Test</button>
-
-</body>
-
-</html>

web/ui-code/package-lock.json

···
-{
-  "name": "ui-code",
-  "version": "0.0.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "ui-code",
-      "version": "0.0.0",
-      "dependencies": {
-        "@atcute/cbor": "^2.2.7",
-        "@atcute/client": "^4.0.4",
-        "@atcute/crypto": "^2.2.5",
-        "@atcute/did-plc": "^0.1.7",
-        "@atcute/identity-resolver": "^1.1.3",
-        "@atcute/multibase": "^1.1.6",
-        "@atproto/api": "^0.16.7",
-        "alpinejs": "^3.15.0",
-        "vite-plugin-full-reload": "^1.2.0",
-        "vite-rs-plugin": "1.0.1"
-      },
-      "devDependencies": {
-        "eslint": "^9.34.0",
-        "eslint-plugin-import": "^2.32.0",
-        "vite": "^7.1.7"
-      }
-    },
-    "node_modules/@atcute/cbor": {
-      "version": "2.2.7",
-      "resolved": "https://registry.npmjs.org/@atcute/cbor/-/cbor-2.2.7.tgz",
-      "integrity": "sha512-/mwAF0gnokOphceZqFq3uzMGdd8sbw5y6bxF8CRutRkCCUcpjjpJc5fkLwhxyGgOveF3mZuHE6p7t/+IAqb7Aw==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/cid": "^2.2.5",
-        "@atcute/multibase": "^1.1.6",
-        "@atcute/uint8array": "^1.0.5"
-      }
-    },
-    "node_modules/@atcute/cid": {
-      "version": "2.2.5",
-      "resolved": "https://registry.npmjs.org/@atcute/cid/-/cid-2.2.5.tgz",
-      "integrity": "sha512-7SId61nMyuxSwsDI02wEZn6/gVeha2TrAN4W0UPSdSEcwQD3R2W8VU7zvR4XGfU7A/KmBnVkwx5FTfzyizKj6g==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/multibase": "^1.1.6",
-        "@atcute/uint8array": "^1.0.5"
-      }
-    },
-    "node_modules/@atcute/client": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/@atcute/client/-/client-4.0.5.tgz",
-      "integrity": "sha512-R8Qen8goGmEkynYGg2m6XFlVmz0GTDvQ+9w+4QqOob+XMk8/WDpF4aImev7WKEde/rV2gjcqW7zM8E6W9NShDA==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/identity": "^1.1.1",
-        "@atcute/lexicons": "^1.2.2"
-      }
-    },
-    "node_modules/@atcute/crypto": {
-      "version": "2.2.5",
-      "resolved": "https://registry.npmjs.org/@atcute/crypto/-/crypto-2.2.5.tgz",
-      "integrity": "sha512-9CbQ9cJ68XewsbLrgdmWQS2uDD9D0hizWFJ3OOZ16TCuARREmzKEpFgHlMxPswR3bDxjwfiXzmYUlHaTqsnxRQ==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/multibase": "^1.1.6",
-        "@atcute/uint8array": "^1.0.5",
-        "@noble/secp256k1": "^2.3.0"
-      }
-    },
-    "node_modules/@atcute/did-plc": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/@atcute/did-plc/-/did-plc-0.1.7.tgz",
-      "integrity": "sha512-a7yOQNqViae3rB5/xa3U0EPJbFD9l8zOHXx6XASZ5F8+Vy2uTgXK3omurpNZ5UxRpy1ni1AMhSohXr61cqWbkg==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/cbor": "^2.2.6",
-        "@atcute/cid": "^2.2.4",
-        "@atcute/crypto": "^2.2.5",
-        "@atcute/identity": "^1.1.1",
-        "@atcute/lexicons": "^1.2.2",
-        "@atcute/multibase": "^1.1.6",
-        "@atcute/uint8array": "^1.0.5",
-        "@badrap/valita": "^0.4.6"
-      }
-    },
-    "node_modules/@atcute/identity": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@atcute/identity/-/identity-1.1.1.tgz",
-      "integrity": "sha512-zax42n693VEhnC+5tndvO2KLDTMkHOz8UExwmklvJv7R9VujfEwiSWhcv6Jgwb3ellaG8wjiQ1lMOIjLLvwh0Q==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/lexicons": "^1.2.2",
-        "@badrap/valita": "^0.4.6"
-      }
-    },
-    "node_modules/@atcute/identity-resolver": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/@atcute/identity-resolver/-/identity-resolver-1.1.4.tgz",
-      "integrity": "sha512-/SVh8vf2cXFJenmBnGeYF2aY3WGQm3cJeew5NWTlkqoy3LvJ5wkvKq9PWu4Tv653VF40rPOp6LOdVr9Fa+q5rA==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/lexicons": "^1.2.2",
-        "@atcute/util-fetch": "^1.0.3",
-        "@badrap/valita": "^0.4.6"
-      },
-      "peerDependencies": {
-        "@atcute/identity": "^1.0.0"
-      }
-    },
-    "node_modules/@atcute/lexicons": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/@atcute/lexicons/-/lexicons-1.2.2.tgz",
-      "integrity": "sha512-bgEhJq5Z70/0TbK5sx+tAkrR8FsCODNiL2gUEvS5PuJfPxmFmRYNWaMGehxSPaXWpU2+Oa9ckceHiYbrItDTkA==",
-      "license": "0BSD",
-      "dependencies": {
-        "@standard-schema/spec": "^1.0.0",
-        "esm-env": "^1.2.2"
-      }
-    },
-    "node_modules/@atcute/multibase": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/@atcute/multibase/-/multibase-1.1.6.tgz",
-      "integrity": "sha512-HBxuCgYLKPPxETV0Rot4VP9e24vKl8JdzGCZOVsDaOXJgbRZoRIF67Lp0H/OgnJeH/Xpva8Z5ReoTNJE5dn3kg==",
-      "license": "0BSD",
-      "dependencies": {
-        "@atcute/uint8array": "^1.0.5"
-      }
-    },
-    "node_modules/@atcute/uint8array": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/@atcute/uint8array/-/uint8array-1.0.5.tgz",
-      "integrity": "sha512-XLWWxoR2HNl2qU+FCr0rp1APwJXci7HnzbOQLxK55OaMNBXZ19+xNC5ii4QCsThsDxa4JS/JTzuiQLziITWf2Q==",
-      "license": "0BSD"
-    },
-    "node_modules/@atcute/util-fetch": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@atcute/util-fetch/-/util-fetch-1.0.3.tgz",
-      "integrity": "sha512-f8zzTb/xlKIwv2OQ31DhShPUNCmIIleX6p7qIXwWwEUjX6x8skUtpdISSjnImq01LXpltGV5y8yhV4/Mlb7CRQ==",
-      "license": "0BSD",
-      "dependencies": {
-        "@badrap/valita": "^0.4.6"
-      }
-    },
-    "node_modules/@atproto/api": {
-      "version": "0.16.11",
-      "resolved": "https://registry.npmjs.org/@atproto/api/-/api-0.16.11.tgz",
-      "integrity": "sha512-1dhfQNHiclb102RW+Ea8Nft5olfqU0Ev/vlQaSX6mWNo1aP5zT+sPODJ8+BTUOYk3vcuvL7QMkqA/rLYy2PMyw==",
-      "license": "MIT",
-      "dependencies": {
-        "@atproto/common-web": "^0.4.3",
-        "@atproto/lexicon": "^0.5.1",
-        "@atproto/syntax": "^0.4.1",
-        "@atproto/xrpc": "^0.7.5",
-        "await-lock": "^2.2.2",
-        "multiformats": "^9.9.0",
-        "tlds": "^1.234.0",
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@atproto/common-web": {
-      "version": "0.4.3",
-      "resolved": "https://registry.npmjs.org/@atproto/common-web/-/common-web-0.4.3.tgz",
-      "integrity": "sha512-nRDINmSe4VycJzPo6fP/hEltBcULFxt9Kw7fQk6405FyAWZiTluYHlXOnU7GkQfeUK44OENG1qFTBcmCJ7e8pg==",
-      "license": "MIT",
-      "dependencies": {
-        "graphemer": "^1.4.0",
-        "multiformats": "^9.9.0",
-        "uint8arrays": "3.0.0",
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@atproto/lexicon": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/@atproto/lexicon/-/lexicon-0.5.1.tgz",
-      "integrity": "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A==",
-      "license": "MIT",
-      "dependencies": {
-        "@atproto/common-web": "^0.4.3",
-        "@atproto/syntax": "^0.4.1",
-        "iso-datestring-validator": "^2.2.2",
-        "multiformats": "^9.9.0",
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@atproto/syntax": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@atproto/syntax/-/syntax-0.4.1.tgz",
-      "integrity": "sha512-CJdImtLAiFO+0z3BWTtxwk6aY5w4t8orHTMVJgkf++QRJWTxPbIFko/0hrkADB7n2EruDxDSeAgfUGehpH6ngw==",
-      "license": "MIT"
-    },
-    "node_modules/@atproto/xrpc": {
-      "version": "0.7.5",
-      "resolved": "https://registry.npmjs.org/@atproto/xrpc/-/xrpc-0.7.5.tgz",
-      "integrity": "sha512-MUYNn5d2hv8yVegRL0ccHvTHAVj5JSnW07bkbiaz96UH45lvYNRVwt44z+yYVnb0/mvBzyD3/ZQ55TRGt7fHkA==",
-      "license": "MIT",
-      "dependencies": {
-        "@atproto/lexicon": "^0.5.1",
-        "zod": "^3.23.8"
-      }
-    },
-    "node_modules/@badrap/valita": {
-      "version": "0.4.6",
-      "resolved": "https://registry.npmjs.org/@badrap/valita/-/valita-0.4.6.tgz",
-      "integrity": "sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.11.tgz",
-      "integrity": "sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg==",
-      "cpu": [
-        "ppc64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.11.tgz",
-      "integrity": "sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.11.tgz",
-      "integrity": "sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.11.tgz",
-      "integrity": "sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.11.tgz",
-      "integrity": "sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.11.tgz",
-      "integrity": "sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.11.tgz",
-      "integrity": "sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.11.tgz",
-      "integrity": "sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.11.tgz",
-      "integrity": "sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.11.tgz",
-      "integrity": "sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.11.tgz",
-      "integrity": "sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.11.tgz",
-      "integrity": "sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw==",
-      "cpu": [
-        "loong64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.11.tgz",
-      "integrity": "sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ==",
-      "cpu": [
-        "mips64el"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.11.tgz",
-      "integrity": "sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw==",
-      "cpu": [
-        "ppc64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.11.tgz",
-      "integrity": "sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww==",
-      "cpu": [
-        "riscv64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.11.tgz",
-      "integrity": "sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw==",
-      "cpu": [
-        "s390x"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.11.tgz",
-      "integrity": "sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.11.tgz",
-      "integrity": "sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.11.tgz",
-      "integrity": "sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.11.tgz",
-      "integrity": "sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.11.tgz",
-      "integrity": "sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.11.tgz",
-      "integrity": "sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.11.tgz",
-      "integrity": "sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.11.tgz",
-      "integrity": "sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.11.tgz",
-      "integrity": "sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.11.tgz",
-      "integrity": "sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.9.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
-      "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eslint-visitor-keys": "^3.4.3"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
-      }
-    },
-    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/@eslint-community/regexpp": {
-      "version": "4.12.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
-      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
-      }
-    },
-    "node_modules/@eslint/config-array": {
-      "version": "0.21.1",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
-      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/object-schema": "^2.1.7",
-        "debug": "^4.3.1",
-        "minimatch": "^3.1.2"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/config-helpers": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.1.tgz",
-      "integrity": "sha512-csZAzkNhsgwb0I/UAV6/RGFTbiakPCf0ZrGmrIxQpYvGZ00PhTkSnyKNolphgIvmnJeGw6rcGVEXfTzUnFuEvw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/core": "^0.16.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/core": {
-      "version": "0.16.0",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.16.0.tgz",
-      "integrity": "sha512-nmC8/totwobIiFcGkDza3GIKfAw1+hLiYVrh3I1nIomQ8PEr5cxg34jnkmGawul/ep52wGRAcyeDCNtWKSOj4Q==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/json-schema": "^7.0.15"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/eslintrc": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz",
-      "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^6.12.4",
-        "debug": "^4.3.2",
-        "espree": "^10.0.1",
-        "globals": "^14.0.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.0",
-        "minimatch": "^3.1.2",
-        "strip-json-comments": "^3.1.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/@eslint/js": {
-      "version": "9.38.0",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.38.0.tgz",
-      "integrity": "sha512-UZ1VpFvXf9J06YG9xQBdnzU+kthors6KjhMAl6f4gH4usHyh31rUf2DLGInT8RFYIReYXNSydgPY0V2LuWgl7A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
-      }
-    },
-    "node_modules/@eslint/object-schema": {
-      "version": "2.1.7",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
-      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/plugin-kit": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.0.tgz",
-      "integrity": "sha512-sB5uyeq+dwCWyPi31B2gQlVlo+j5brPlWx4yZBrEaRo/nhdDE8Xke1gsGgtiBdaBTxuTkceLVuVt/pclrasb0A==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/core": "^0.16.0",
-        "levn": "^0.4.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@humanfs/core": {
-      "version": "0.19.1",
-      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
-      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/@humanfs/node": {
-      "version": "0.16.7",
-      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
-      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@humanfs/core": "^0.19.1",
-        "@humanwhocodes/retry": "^0.4.0"
-      },
-      "engines": {
-        "node": ">=18.18.0"
-      }
-    },
-    "node_modules/@humanwhocodes/module-importer": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
-      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=12.22"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@humanwhocodes/retry": {
-      "version": "0.4.3",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
-      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@noble/secp256k1": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-2.3.0.tgz",
-      "integrity": "sha512-0TQed2gcBbIrh7Ccyw+y/uZQvbJwm7Ao4scBUxqpBCcsOlZG0O4KGfjtNAy/li4W8n1xt3dxrwJ0beZ2h2G6Kw==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.5.tgz",
-      "integrity": "sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.5.tgz",
-      "integrity": "sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.5.tgz",
-      "integrity": "sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.5.tgz",
-      "integrity": "sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.5.tgz",
-      "integrity": "sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.5.tgz",
-      "integrity": "sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.5.tgz",
-      "integrity": "sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.5.tgz",
-      "integrity": "sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.5.tgz",
-      "integrity": "sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.5.tgz",
-      "integrity": "sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.5.tgz",
-      "integrity": "sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA==",
-      "cpu": [
-        "loong64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.5.tgz",
-      "integrity": "sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw==",
-      "cpu": [
-        "ppc64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.5.tgz",
-      "integrity": "sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw==",
-      "cpu": [
-        "riscv64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.5.tgz",
-      "integrity": "sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg==",
-      "cpu": [
-        "riscv64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.5.tgz",
-      "integrity": "sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.5.tgz",
-      "integrity": "sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.5.tgz",
-      "integrity": "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.5.tgz",
-      "integrity": "sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.5.tgz",
-      "integrity": "sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.5.tgz",
-      "integrity": "sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.5.tgz",
-      "integrity": "sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.5.tgz",
-      "integrity": "sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rtsao/scc": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
-      "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@standard-schema/spec": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.0.0.tgz",
-      "integrity": "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==",
-      "license": "MIT"
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
-      "license": "MIT"
-    },
-    "node_modules/@types/json-schema": {
-      "version": "7.0.15",
-      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
-      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/json5": {
-      "version": "0.0.29",
-      "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz",
-      "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@vue/reactivity": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.1.5.tgz",
-      "integrity": "sha512-1tdfLmNjWG6t/CsPldh+foumYFo3cpyCHgBYQ34ylaMsJ+SNHQ1kApMIa8jN+i593zQuaw3AdWH0nJTARzCFhg==",
-      "license": "MIT",
-      "dependencies": {
-        "@vue/shared": "3.1.5"
-      }
-    },
-    "node_modules/@vue/shared": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.1.5.tgz",
-      "integrity": "sha512-oJ4F3TnvpXaQwZJNF3ZK+kLPHKarDmJjJ6jyzVNDKH9md1dptjC7lWR//jrGuLdek/U6iltWxqAnYOu8gCiOvA==",
-      "license": "MIT"
-    },
-    "node_modules/acorn": {
-      "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-jsx": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
-      }
-    },
-    "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/alpinejs": {
-      "version": "3.15.0",
-      "resolved": "https://registry.npmjs.org/alpinejs/-/alpinejs-3.15.0.tgz",
-      "integrity": "sha512-lpokA5okCF1BKh10LG8YjqhfpxyHBk4gE7boIgVHltJzYoM7O9nK3M7VlntLEJGsVmu7U/RzUWajmHREGT38Eg==",
-      "license": "MIT",
-      "dependencies": {
-        "@vue/reactivity": "~3.1.1"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
-      "dev": true,
-      "license": "Python-2.0"
-    },
-    "node_modules/array-buffer-byte-length": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
-      "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "is-array-buffer": "^3.0.5"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/array-includes": {
-      "version": "3.1.9",
-      "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.9.tgz",
-      "integrity": "sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.24.0",
-        "es-object-atoms": "^1.1.1",
-        "get-intrinsic": "^1.3.0",
-        "is-string": "^1.1.1",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/array.prototype.findlastindex": {
-      "version": "1.2.6",
-      "resolved": "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz",
-      "integrity": "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.9",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "es-shim-unscopables": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/array.prototype.flat": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz",
-      "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-shim-unscopables": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/array.prototype.flatmap": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz",
-      "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-shim-unscopables": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/arraybuffer.prototype.slice": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz",
-      "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-buffer-byte-length": "^1.0.1",
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "is-array-buffer": "^3.0.4"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/async-function": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",
-      "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/available-typed-arrays": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
-      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "possible-typed-array-names": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/await-lock": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/await-lock/-/await-lock-2.2.2.tgz",
-      "integrity": "sha512-aDczADvlvTGajTDjcjpJMqRkOF6Qdz3YbPZm/PyW6tKPkx2hlYBzxMhEywM/tU72HrVZjgl5VCdRuMlA7pZ8Gw==",
-      "license": "MIT"
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/call-bound": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
-      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "get-intrinsic": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/data-view-buffer": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
-      "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/data-view-byte-length": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz",
-      "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/inspect-js"
-      }
-    },
-    "node_modules/data-view-byte-offset": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz",
-      "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/deep-is": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
-      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/define-properties": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
-      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.0.1",
-        "has-property-descriptors": "^1.0.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/doctrine": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
-      "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "esutils": "^2.0.2"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-abstract": {
-      "version": "1.24.0",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.0.tgz",
-      "integrity": "sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-buffer-byte-length": "^1.0.2",
-        "arraybuffer.prototype.slice": "^1.0.4",
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "data-view-buffer": "^1.0.2",
-        "data-view-byte-length": "^1.0.2",
-        "data-view-byte-offset": "^1.0.1",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "es-set-tostringtag": "^2.1.0",
-        "es-to-primitive": "^1.3.0",
-        "function.prototype.name": "^1.1.8",
-        "get-intrinsic": "^1.3.0",
-        "get-proto": "^1.0.1",
-        "get-symbol-description": "^1.1.0",
-        "globalthis": "^1.0.4",
-        "gopd": "^1.2.0",
-        "has-property-descriptors": "^1.0.2",
-        "has-proto": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "internal-slot": "^1.1.0",
-        "is-array-buffer": "^3.0.5",
-        "is-callable": "^1.2.7",
-        "is-data-view": "^1.0.2",
-        "is-negative-zero": "^2.0.3",
-        "is-regex": "^1.2.1",
-        "is-set": "^2.0.3",
-        "is-shared-array-buffer": "^1.0.4",
-        "is-string": "^1.1.1",
-        "is-typed-array": "^1.1.15",
-        "is-weakref": "^1.1.1",
-        "math-intrinsics": "^1.1.0",
-        "object-inspect": "^1.13.4",
-        "object-keys": "^1.1.1",
-        "object.assign": "^4.1.7",
-        "own-keys": "^1.0.1",
-        "regexp.prototype.flags": "^1.5.4",
-        "safe-array-concat": "^1.1.3",
-        "safe-push-apply": "^1.0.0",
-        "safe-regex-test": "^1.1.0",
-        "set-proto": "^1.0.0",
-        "stop-iteration-iterator": "^1.1.0",
-        "string.prototype.trim": "^1.2.10",
-        "string.prototype.trimend": "^1.0.9",
-        "string.prototype.trimstart": "^1.0.8",
-        "typed-array-buffer": "^1.0.3",
-        "typed-array-byte-length": "^1.0.3",
-        "typed-array-byte-offset": "^1.0.4",
-        "typed-array-length": "^1.0.7",
-        "unbox-primitive": "^1.1.0",
-        "which-typed-array": "^1.1.19"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-set-tostringtag": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
-      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-shim-unscopables": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz",
-      "integrity": "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-to-primitive": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz",
-      "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7",
-        "is-date-object": "^1.0.5",
-        "is-symbol": "^1.0.4"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/esbuild": {
-      "version": "0.25.11",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.11.tgz",
-      "integrity": "sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.25.11",
-        "@esbuild/android-arm": "0.25.11",
-        "@esbuild/android-arm64": "0.25.11",
-        "@esbuild/android-x64": "0.25.11",
-        "@esbuild/darwin-arm64": "0.25.11",
-        "@esbuild/darwin-x64": "0.25.11",
-        "@esbuild/freebsd-arm64": "0.25.11",
-        "@esbuild/freebsd-x64": "0.25.11",
-        "@esbuild/linux-arm": "0.25.11",
-        "@esbuild/linux-arm64": "0.25.11",
-        "@esbuild/linux-ia32": "0.25.11",
-        "@esbuild/linux-loong64": "0.25.11",
-        "@esbuild/linux-mips64el": "0.25.11",
-        "@esbuild/linux-ppc64": "0.25.11",
-        "@esbuild/linux-riscv64": "0.25.11",
-        "@esbuild/linux-s390x": "0.25.11",
-        "@esbuild/linux-x64": "0.25.11",
-        "@esbuild/netbsd-arm64": "0.25.11",
-        "@esbuild/netbsd-x64": "0.25.11",
-        "@esbuild/openbsd-arm64": "0.25.11",
-        "@esbuild/openbsd-x64": "0.25.11",
-        "@esbuild/openharmony-arm64": "0.25.11",
-        "@esbuild/sunos-x64": "0.25.11",
-        "@esbuild/win32-arm64": "0.25.11",
-        "@esbuild/win32-ia32": "0.25.11",
-        "@esbuild/win32-x64": "0.25.11"
-      }
-    },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint": {
-      "version": "9.38.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.38.0.tgz",
-      "integrity": "sha512-t5aPOpmtJcZcz5UJyY2GbvpDlsK5E8JqRqoKtfiKE3cNh437KIqfJr3A3AKf5k64NPx6d0G3dno6XDY05PqPtw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.8.0",
-        "@eslint-community/regexpp": "^4.12.1",
-        "@eslint/config-array": "^0.21.1",
-        "@eslint/config-helpers": "^0.4.1",
-        "@eslint/core": "^0.16.0",
-        "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "9.38.0",
-        "@eslint/plugin-kit": "^0.4.0",
-        "@humanfs/node": "^0.16.6",
-        "@humanwhocodes/module-importer": "^1.0.1",
-        "@humanwhocodes/retry": "^0.4.2",
-        "@types/estree": "^1.0.6",
-        "ajv": "^6.12.4",
-        "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.6",
-        "debug": "^4.3.2",
-        "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^8.4.0",
-        "eslint-visitor-keys": "^4.2.1",
-        "espree": "^10.4.0",
-        "esquery": "^1.5.0",
-        "esutils": "^2.0.2",
-        "fast-deep-equal": "^3.1.3",
-        "file-entry-cache": "^8.0.0",
-        "find-up": "^5.0.0",
-        "glob-parent": "^6.0.2",
-        "ignore": "^5.2.0",
-        "imurmurhash": "^0.1.4",
-        "is-glob": "^4.0.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.9.3"
-      },
-      "bin": {
-        "eslint": "bin/eslint.js"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
-      },
-      "peerDependencies": {
-        "jiti": "*"
-      },
-      "peerDependenciesMeta": {
-        "jiti": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/eslint-import-resolver-node": {
-      "version": "0.3.9",
-      "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz",
-      "integrity": "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^3.2.7",
-        "is-core-module": "^2.13.0",
-        "resolve": "^1.22.4"
-      }
-    },
-    "node_modules/eslint-import-resolver-node/node_modules/debug": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
-      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.1"
-      }
-    },
-    "node_modules/eslint-module-utils": {
-      "version": "2.12.1",
-      "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz",
-      "integrity": "sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^3.2.7"
-      },
-      "engines": {
-        "node": ">=4"
-      },
-      "peerDependenciesMeta": {
-        "eslint": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/eslint-module-utils/node_modules/debug": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
-      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.1"
-      }
-    },
-    "node_modules/eslint-plugin-import": {
-      "version": "2.32.0",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz",
-      "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@rtsao/scc": "^1.1.0",
-        "array-includes": "^3.1.9",
-        "array.prototype.findlastindex": "^1.2.6",
-        "array.prototype.flat": "^1.3.3",
-        "array.prototype.flatmap": "^1.3.3",
-        "debug": "^3.2.7",
-        "doctrine": "^2.1.0",
-        "eslint-import-resolver-node": "^0.3.9",
-        "eslint-module-utils": "^2.12.1",
-        "hasown": "^2.0.2",
-        "is-core-module": "^2.16.1",
-        "is-glob": "^4.0.3",
-        "minimatch": "^3.1.2",
-        "object.fromentries": "^2.0.8",
-        "object.groupby": "^1.0.3",
-        "object.values": "^1.2.1",
-        "semver": "^6.3.1",
-        "string.prototype.trimend": "^1.0.9",
-        "tsconfig-paths": "^3.15.0"
-      },
-      "engines": {
-        "node": ">=4"
-      },
-      "peerDependencies": {
-        "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9"
-      }
-    },
-    "node_modules/eslint-plugin-import/node_modules/debug": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
-      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.1"
-      }
-    },
-    "node_modules/eslint-scope": {
-      "version": "8.4.0",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
-      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint-visitor-keys": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
-      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/esm-env": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
-      "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==",
-      "license": "MIT"
-    },
-    "node_modules/espree": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
-      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "acorn": "^8.15.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^4.2.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/esquery": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "estraverse": "^5.1.0"
-      },
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
-    "node_modules/esrecurse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
-      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/estraverse": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
-      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-json-stable-stringify": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
-      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-levenshtein": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fdir": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
-      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
-      },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/file-entry-cache": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
-      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flat-cache": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=16.0.0"
-      }
-    },
-    "node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/flat-cache": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
-      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "flatted": "^3.2.9",
-        "keyv": "^4.5.4"
-      },
-      "engines": {
-        "node": ">=16"
-      }
-    },
-    "node_modules/flatted": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/for-each": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
-      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
-    },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/function.prototype.name": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz",
-      "integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "functions-have-names": "^1.2.3",
-        "hasown": "^2.0.2",
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/functions-have-names": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
-      "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/generator-function": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
-      "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/get-symbol-description": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",
-      "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/glob-parent": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "is-glob": "^4.0.3"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/globalthis": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
-      "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-properties": "^1.2.1",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/graphemer": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
-      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
-      "license": "MIT"
-    },
-    "node_modules/has-bigints": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
-      "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-proto": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz",
-      "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-tostringtag": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-symbols": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/import-fresh": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
-      }
-    },
-    "node_modules/internal-slot": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
-      "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "hasown": "^2.0.2",
-        "side-channel": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/is-array-buffer": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
-      "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-async-function": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz",
-      "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "async-function": "^1.0.0",
-        "call-bound": "^1.0.3",
-        "get-proto": "^1.0.1",
-        "has-tostringtag": "^1.0.2",
-        "safe-regex-test": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-bigint": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
-      "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-bigints": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-boolean-object": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
-      "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-callable": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
-      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-core-module": {
-      "version": "2.16.1",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
-      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-data-view": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz",
-      "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "get-intrinsic": "^1.2.6",
-        "is-typed-array": "^1.1.13"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-date-object": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
-      "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-finalizationregistry": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz",
-      "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-generator-function": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz",
-      "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.4",
-        "generator-function": "^2.0.0",
-        "get-proto": "^1.0.1",
-        "has-tostringtag": "^1.0.2",
-        "safe-regex-test": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-map": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
-      "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-negative-zero": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
-      "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-number-object": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
-      "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-regex": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
-      "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-set": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
-      "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-shared-array-buffer": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
-      "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-string": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
-      "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-symbol": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
-      "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-symbols": "^1.1.0",
-        "safe-regex-test": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-typed-array": {
-      "version": "1.1.15",
-      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
-      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "which-typed-array": "^1.1.16"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakmap": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
-      "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakref": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz",
-      "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakset": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
-      "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/isarray": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
-      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/iso-datestring-validator": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/iso-datestring-validator/-/iso-datestring-validator-2.2.2.tgz",
-      "integrity": "sha512-yLEMkBbLZTlVQqOnQ4FiMujR6T4DEcCb1xizmvXS+OxuhwcbtynoosRzdMA69zZCShCNAbi+gJ71FxZBBXx1SA==",
-      "license": "MIT"
-    },
-    "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/json-buffer": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json5": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz",
-      "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "minimist": "^1.2.0"
-      },
-      "bin": {
-        "json5": "lib/cli.js"
-      }
-    },
-    "node_modules/keyv": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "json-buffer": "3.0.1"
-      }
-    },
-    "node_modules/levn": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
-      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/minimist": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/multiformats": {
-      "version": "9.9.0",
-      "resolved": "https://registry.npmjs.org/multiformats/-/multiformats-9.9.0.tgz",
-      "integrity": "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==",
-      "license": "(Apache-2.0 AND MIT)"
-    },
-    "node_modules/nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
-      },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
-      }
-    },
-    "node_modules/natural-compare": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
-      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/object-inspect": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object-keys": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
-      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/object.assign": {
-      "version": "4.1.7",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
-      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0",
-        "has-symbols": "^1.1.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object.fromentries": {
-      "version": "2.0.8",
-      "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz",
-      "integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.2",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object.groupby": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz",
-      "integrity": "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/object.values": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz",
-      "integrity": "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/optionator": {
-      "version": "0.9.4",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
-      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "deep-is": "^0.1.3",
-        "fast-levenshtein": "^2.0.6",
-        "levn": "^0.4.1",
-        "prelude-ls": "^1.2.1",
-        "type-check": "^0.4.0",
-        "word-wrap": "^1.2.5"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/own-keys": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz",
-      "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "get-intrinsic": "^1.2.6",
-        "object-keys": "^1.1.1",
-        "safe-push-apply": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "yocto-queue": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "callsites": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-parse": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
-      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "license": "ISC"
-    },
-    "node_modules/picomatch": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/possible-typed-array-names": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
-      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/postcss": {
-      "version": "8.5.6",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
-      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "nanoid": "^3.3.11",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
-      },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
-      }
-    },
-    "node_modules/prelude-ls": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
-      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/reflect.getprototypeof": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
-      "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.9",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.0.0",
-        "get-intrinsic": "^1.2.7",
-        "get-proto": "^1.0.1",
-        "which-builtin-type": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/regexp.prototype.flags": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
-      "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-errors": "^1.3.0",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "set-function-name": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/resolve": {
-      "version": "1.22.10",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
-      "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-core-module": "^2.16.0",
-        "path-parse": "^1.0.7",
-        "supports-preserve-symlinks-flag": "^1.0.0"
-      },
-      "bin": {
-        "resolve": "bin/resolve"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/rollup": {
-      "version": "4.52.5",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.5.tgz",
-      "integrity": "sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "1.0.8"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
-      },
-      "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.52.5",
-        "@rollup/rollup-android-arm64": "4.52.5",
-        "@rollup/rollup-darwin-arm64": "4.52.5",
-        "@rollup/rollup-darwin-x64": "4.52.5",
-        "@rollup/rollup-freebsd-arm64": "4.52.5",
-        "@rollup/rollup-freebsd-x64": "4.52.5",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.52.5",
-        "@rollup/rollup-linux-arm-musleabihf": "4.52.5",
-        "@rollup/rollup-linux-arm64-gnu": "4.52.5",
-        "@rollup/rollup-linux-arm64-musl": "4.52.5",
-        "@rollup/rollup-linux-loong64-gnu": "4.52.5",
-        "@rollup/rollup-linux-ppc64-gnu": "4.52.5",
-        "@rollup/rollup-linux-riscv64-gnu": "4.52.5",
-        "@rollup/rollup-linux-riscv64-musl": "4.52.5",
-        "@rollup/rollup-linux-s390x-gnu": "4.52.5",
-        "@rollup/rollup-linux-x64-gnu": "4.52.5",
-        "@rollup/rollup-linux-x64-musl": "4.52.5",
-        "@rollup/rollup-openharmony-arm64": "4.52.5",
-        "@rollup/rollup-win32-arm64-msvc": "4.52.5",
-        "@rollup/rollup-win32-ia32-msvc": "4.52.5",
-        "@rollup/rollup-win32-x64-gnu": "4.52.5",
-        "@rollup/rollup-win32-x64-msvc": "4.52.5",
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/safe-array-concat": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz",
-      "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "get-intrinsic": "^1.2.6",
-        "has-symbols": "^1.1.0",
-        "isarray": "^2.0.5"
-      },
-      "engines": {
-        "node": ">=0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/safe-push-apply": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
-      "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "isarray": "^2.0.5"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/safe-regex-test": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
-      "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-regex": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/set-function-length": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
-      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "gopd": "^1.0.1",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/set-function-name": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
-      "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "functions-have-names": "^1.2.3",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/set-proto": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz",
-      "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "shebang-regex": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
-        "side-channel-map": "^1.0.1",
-        "side-channel-weakmap": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-map": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
-      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-weakmap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
-      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3",
-        "side-channel-map": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/source-map-js": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/stop-iteration-iterator": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
-      "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "internal-slot": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/string.prototype.trim": {
-      "version": "1.2.10",
-      "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz",
-      "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "define-data-property": "^1.1.4",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-object-atoms": "^1.0.0",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/string.prototype.trimend": {
-      "version": "1.0.9",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz",
-      "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/string.prototype.trimstart": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
-      "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/strip-bom": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
-      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/supports-preserve-symlinks-flag": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
-      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/tinyglobby": {
-      "version": "0.2.15",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
-      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
-      "license": "MIT",
-      "dependencies": {
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/SuperchupuDev"
-      }
-    },
-    "node_modules/tlds": {
-      "version": "1.260.0",
-      "resolved": "https://registry.npmjs.org/tlds/-/tlds-1.260.0.tgz",
-      "integrity": "sha512-78+28EWBhCEE7qlyaHA9OR3IPvbCLiDh3Ckla593TksfFc9vfTsgvH7eS+dr3o9qr31gwGbogcI16yN91PoRjQ==",
-      "license": "MIT",
-      "bin": {
-        "tlds": "bin.js"
-      }
-    },
-    "node_modules/tsconfig-paths": {
-      "version": "3.15.0",
-      "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz",
-      "integrity": "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/json5": "^0.0.29",
-        "json5": "^1.0.2",
-        "minimist": "^1.2.6",
-        "strip-bom": "^3.0.0"
-      }
-    },
-    "node_modules/type-check": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
-      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/typed-array-buffer": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
-      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-typed-array": "^1.1.14"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/typed-array-byte-length": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz",
-      "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "for-each": "^0.3.3",
-        "gopd": "^1.2.0",
-        "has-proto": "^1.2.0",
-        "is-typed-array": "^1.1.14"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/typed-array-byte-offset": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz",
-      "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "for-each": "^0.3.3",
-        "gopd": "^1.2.0",
-        "has-proto": "^1.2.0",
-        "is-typed-array": "^1.1.15",
-        "reflect.getprototypeof": "^1.0.9"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/typed-array-length": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz",
-      "integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "for-each": "^0.3.3",
-        "gopd": "^1.0.1",
-        "is-typed-array": "^1.1.13",
-        "possible-typed-array-names": "^1.0.0",
-        "reflect.getprototypeof": "^1.0.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/uint8arrays": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/uint8arrays/-/uint8arrays-3.0.0.tgz",
-      "integrity": "sha512-HRCx0q6O9Bfbp+HHSfQQKD7wU70+lydKVt4EghkdOvlK/NlrF90z+eXV34mUd48rNvVJXwkrMSPpCATkct8fJA==",
-      "license": "MIT",
-      "dependencies": {
-        "multiformats": "^9.4.2"
-      }
-    },
-    "node_modules/unbox-primitive": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
-      "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-bigints": "^1.0.2",
-        "has-symbols": "^1.1.0",
-        "which-boxed-primitive": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/uri-js": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
-      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "punycode": "^2.1.0"
-      }
-    },
-    "node_modules/vite": {
-      "version": "7.1.10",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.1.10.tgz",
-      "integrity": "sha512-CmuvUBzVJ/e3HGxhg6cYk88NGgTnBoOo7ogtfJJ0fefUWAxN/WDSUa50o+oVBxuIhO8FoEZW0j2eW7sfjs5EtA==",
-      "license": "MIT",
-      "dependencies": {
-        "esbuild": "^0.25.0",
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3",
-        "postcss": "^8.5.6",
-        "rollup": "^4.43.0",
-        "tinyglobby": "^0.2.15"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^20.19.0 || >=22.12.0",
-        "jiti": ">=1.21.0",
-        "less": "^4.0.0",
-        "lightningcss": "^1.21.0",
-        "sass": "^1.70.0",
-        "sass-embedded": "^1.70.0",
-        "stylus": ">=0.54.8",
-        "sugarss": "^5.0.0",
-        "terser": "^5.16.0",
-        "tsx": "^4.8.1",
-        "yaml": "^2.4.2"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "jiti": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "sass-embedded": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        },
-        "tsx": {
-          "optional": true
-        },
-        "yaml": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/vite-plugin-full-reload": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/vite-plugin-full-reload/-/vite-plugin-full-reload-1.2.0.tgz",
-      "integrity": "sha512-kz18NW79x0IHbxRSHm0jttP4zoO9P9gXh+n6UTwlNKnviTTEpOlum6oS9SmecrTtSr+muHEn5TUuC75UovQzcA==",
-      "license": "MIT",
-      "dependencies": {
-        "picocolors": "^1.0.0",
-        "picomatch": "^2.3.1"
-      }
-    },
-    "node_modules/vite-plugin-full-reload/node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/vite-rs-plugin": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/vite-rs-plugin/-/vite-rs-plugin-1.0.1.tgz",
-      "integrity": "sha512-YhgflKQIRzuS5x66J3yICoVLH25D2fNU+jThK8tpYl/jGrXeIKT4w5VH1lkLPRC0SjK2ZCm9S6K9Z2ZFVDHjPQ==",
-      "license": "MIT",
-      "dependencies": {
-        "vite-plugin-full-reload": "^1.2.0"
-      },
-      "bin": {
-        "cleanup": "bin/cleanForBuild.js"
-      },
-      "peerDependencies": {
-        "vite": "^5.0.0"
-      }
-    },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/which-boxed-primitive": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
-      "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-bigint": "^1.1.0",
-        "is-boolean-object": "^1.2.1",
-        "is-number-object": "^1.1.1",
-        "is-string": "^1.1.1",
-        "is-symbol": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-builtin-type": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz",
-      "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "function.prototype.name": "^1.1.6",
-        "has-tostringtag": "^1.0.2",
-        "is-async-function": "^2.0.0",
-        "is-date-object": "^1.1.0",
-        "is-finalizationregistry": "^1.1.0",
-        "is-generator-function": "^1.0.10",
-        "is-regex": "^1.2.1",
-        "is-weakref": "^1.0.2",
-        "isarray": "^2.0.5",
-        "which-boxed-primitive": "^1.1.0",
-        "which-collection": "^1.0.2",
-        "which-typed-array": "^1.1.16"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-collection": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
-      "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-map": "^2.0.3",
-        "is-set": "^2.0.3",
-        "is-weakmap": "^2.0.2",
-        "is-weakset": "^2.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-typed-array": {
-      "version": "1.1.19",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
-      "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "for-each": "^0.3.5",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/word-wrap": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
-      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/zod": {
-      "version": "3.25.76",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
-      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    }
-  }
-}

web/ui-code/package.json

···
-{
-  "name": "ui-code",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "build:watch": "vite build -w",
-    "preview": "vite preview",
-    "lint": "eslint src --ext .js",
-    "lint:fix": "eslint src --ext .js --fix"
-  },
-  "devDependencies": {
-    "eslint": "^9.34.0",
-    "eslint-plugin-import": "^2.32.0",
-    "vite": "^7.1.7"
-  },
-  "dependencies": {
-    "@atcute/cbor": "^2.2.7",
-    "@atcute/client": "^4.0.4",
-    "@atcute/crypto": "^2.2.5",
-    "@atcute/did-plc": "^0.1.7",
-    "@atcute/identity-resolver": "^1.1.3",
-    "@atcute/multibase": "^1.1.6",
-    "@atproto/api": "^0.16.7",
-    "alpinejs": "^3.15.0",
-    "vite-plugin-full-reload": "^1.2.0",
-    "vite-rs-plugin": "1.0.1"
-  }
-}

web/ui-code/src/atprotoUtils.js

···
-import {
-  CompositeDidDocumentResolver, CompositeHandleResolver,
-  DohJsonHandleResolver,
-  PlcDidDocumentResolver, WebDidDocumentResolver,
-  WellKnownHandleResolver
-} from '@atcute/identity-resolver';
-import {Client, simpleFetchHandler} from '@atcute/client';
-
-const handleResolver = new CompositeHandleResolver({
-  strategy: 'race',
-  methods: {
-    dns: new DohJsonHandleResolver({
-      dohUrl: 'https://mozilla.cloudflare-dns.com/dns-query',
-    }),
-    http: new WellKnownHandleResolver(),
-  },
-});
-
-const docResolver = new CompositeDidDocumentResolver({
-  methods: {
-    plc: new PlcDidDocumentResolver(),
-    web: new WebDidDocumentResolver(),
-  },
-});
-
-const cleanHandle = (handle) =>
-  handle.replace('@', '').trim().replace(
-    /[\u202A\u202C\u200E\u200F\u2066-\u2069]/g,
-    '',
-  );
-
-
-async function handleAndPDSResolver(handle) {
-  let usersDid = null;
-  if (handle.startsWith('did:')) {
-    usersDid = handle;
-  } else {
-    const cleanedHandle = cleanHandle(handle);
-    usersDid = await handleResolver.resolve(cleanedHandle);
-  }
-  const didDoc = await docResolver.resolve(usersDid);
-
-  let pds;
-  try {
-    pds = didDoc.service?.filter((s) =>
-      s.type === 'AtprotoPersonalDataServer'
-    )[0].serviceEndpoint;
-  } catch (error) {
-    console.error(error);
-    throw new Error('Could not find a PDS in the DID document.');
-  }
-  return {usersDid, pds};
-}
-
-
-async function fetchPDSMooverDIDWeb(baseUrl) {
-  const response = await fetch(`${baseUrl}/.well-known/did.json`);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch DID document: ${response.status}`);
-  }
-  const didDoc = await response.json();
-  return didDoc.id;
-}
-
-async function describeServer() {
-  const baseUrl = window.location.origin;
-  const handler = simpleFetchHandler({service: baseUrl});
-  const rpc = new Client({
-    handler
-  });
-
-  let describeServerResponse = await rpc.get('com.pdsmoover.backup.describeServer');
-  if (describeServerResponse.ok) {
-    return describeServerResponse.data;
-  } else {
-    throw new Error('Could not describe server');
-  }
-
-
-}
-
-
-export {handleResolver, docResolver, cleanHandle, handleAndPDSResolver, fetchPDSMooverDIDWeb, describeServer};

web/ui-code/src/backup.js

···
-import {Client, CredentialManager, ok} from '@atcute/client';
-import {fetchPDSMooverDIDWeb, handleAndPDSResolver} from './atprotoUtils.js';
-
-
-class BackupService {
-  constructor() {
-    /**
-         *
-         * @type {Client}
-         */
-    this.atCuteClient = null;
-    /**
-         *
-         * @type {CredentialManager}
-         */
-    this.atCuteCredentialManager = null;
-  }
-
-  // Perform backup sign-up using user credentials. If the server requires 2FA,
-  // it will throw with error.error === 'AuthFactorTokenRequired'.
-  async loginAndStatus(identifier, password, onStatus = null, twoFactorCode = null) {
-    let {pds} = await handleAndPDSResolver(identifier);
-
-
-    const manager = new CredentialManager({
-      service: pds
-    });
-
-    //TODO prob should be a function param, but eh
-    const didWeb = await fetchPDSMooverDIDWeb(window.location.origin);
-
-    const rpc = new Client({
-      handler: manager,
-      proxy: {
-        did: didWeb,
-        serviceId: '#repo_backup'
-      }
-    });
-
-    try {
-      if (onStatus) onStatus('Signing in…');
-
-      let loginInput = {
-        identifier,
-        password,
-
-      };
-      if (twoFactorCode) {
-        loginInput.code = twoFactorCode;
-      }
-      await manager.login(loginInput);
-
-
-      // Make the client/manager available regardless of repo status so we can sign up if needed.
-      this.atCuteClient = rpc;
-      this.atCuteCredentialManager = manager;
-
-      if (onStatus) onStatus('Checking backup status');
-      const result = await rpc.get('com.pdsmoover.backup.getRepoStatus', {
-        params: {
-          did: manager.session.did.toString()
-        }
-      });
-      if (result.ok) {
-        return result.data;
-      } else {
-        switch (result.data.error) {
-        case 'RepoNotFound':
-          console.log('Repo not found');
-          return null;
-        default:
-          throw result.data.error;
-        }
-
-      }
-    } catch (err) {
-      throw err;
-    }
-  }
-
-  // Sign up for backups. Optionally create a new recovery key on signup.
-  async signUp(onStatus = null) {
-    if (!this.atCuteClient || !this.atCuteCredentialManager) {
-      throw new Error('Not signed in');
-    }
-    if (onStatus) onStatus('Creating backup registration…');
-    const data = await ok(
-      this.atCuteClient.post('com.pdsmoover.backup.signUp', {
-        as: null,
-      })
-    );
-    if (onStatus) onStatus('Backup registration complete');
-    return data;
-  }
-
-  async requestAPlcToken() {
-    if (!this.atCuteClient || !this.atCuteCredentialManager) {
-      throw new Error('Not signed in');
-    }
-    const rpc = new Client({
-      handler: this.atCuteCredentialManager,
-    });
-
-    let response = await rpc.post('com.atproto.identity.requestPlcOperationSignature', {
-      as: null,
-    });
-    if (!response.ok) {
-      throw new Error(response.data?.message || 'Failed to request PLC token');
-    }
-  }
-
-  async addANewRotationKey(plcToken, rotationKey) {
-    if (!this.atCuteClient || !this.atCuteCredentialManager) {
-      throw new Error('Not signed in');
-    }
-
-
-    const rpc = new Client({
-      handler: this.atCuteCredentialManager,
-    });
-
-    let getDidCredentials = await rpc.get('com.atproto.identity.getRecommendedDidCredentials');
-
-    if (getDidCredentials.ok) {
-      const pdsProvidedRotationKeys = getDidCredentials.data.rotationKeys ?? [];
-      const updatedRotationKeys = [rotationKey, ...pdsProvidedRotationKeys];
-
-      const credentials = {
-        ...getDidCredentials.data,
-        rotationKeys: updatedRotationKeys,
-      };
-
-      const signDocRes = await rpc.post('com.atproto.identity.signPlcOperation', {
-        input: {
-          token: plcToken,
-          ...credentials,
-        }
-      });
-
-      if (signDocRes.ok) {
-        const submitDocRes = await rpc.post('com.atproto.identity.submitPlcOperation', {
-          input: signDocRes.data,
-          as: null,
-        });
-
-        if (!submitDocRes.ok) {
-          throw new Error(submitDocRes.data?.message || 'Failed to submit PLC operation');
-        }
-
-      } else {
-        throw new Error(signDocRes.data?.message || 'Failed to sign PLC operation');
-      }
-
-
-    } else {
-      throw new Error(getDidCredentials.data?.message || 'Failed to get status');
-    }
-  }
-
-  async getUsersRepoStatus(onStatus = null) {
-    if (!this.atCuteClient || !this.atCuteCredentialManager) {
-      throw new Error('Not signed in');
-    }
-    if (onStatus) onStatus('Refreshing backup status…');
-    const result = await this.atCuteClient.get('com.pdsmoover.backup.getRepoStatus', {
-      params: {did: this.atCuteCredentialManager.session.did.toString()}
-    });
-    if (result.ok) {
-      return result.data;
-    } else {
-      throw new Error(result.data?.message || 'Failed to get status');
-    }
-  }
-
-  async runBackupNow(onStatus = null) {
-    if (!this.atCuteClient || !this.atCuteCredentialManager) {
-      throw new Error('Not signed in');
-    }
-    if (onStatus) onStatus('Requesting backup…');
-    const res = await this.atCuteClient.post('com.pdsmoover.backup.requestBackup', {as: null, data: {}});
-    if (res.ok) {
-      if (onStatus) onStatus('Backup requested.');
-      // After requesting, refresh status to reflect any immediate changes
-      try {
-        await this.refreshStatus(onStatus);
-      } catch (_) { /* ignore */
-      }
-      return true;
-    } else {
-      const err = res.data;
-      if (err?.error === 'Timeout') {
-        throw {error: 'Timeout', message: err?.message || 'Please wait a few minutes before requesting again.'};
-      }
-      throw new Error(err?.message || 'Failed to request backup');
-    }
-  }
-
-  // Remove (delete) the user's backup repository
-  async removeRepo(onStatus = null) {
-    if (!this.atCuteClient || !this.atCuteCredentialManager) {
-      throw new Error('Not signed in');
-    }
-    if (onStatus) onStatus('Deleting backup repository…');
-    const res = await this.atCuteClient.post('com.pdsmoover.backup.removeRepo', {as: null, data: {}});
-    if (res.ok) {
-      if (onStatus) onStatus('Backup repository deleted.');
-      return true;
-    } else {
-      const err = res.data;
-      throw new Error(err?.message || 'Failed to delete backup repository');
-    }
-  }
-}
-
-
-export {BackupService};

web/ui-code/src/main.js

···
-import {Migrator} from './pdsmoover.js';
-import {MissingBlobs} from './missingBlobs.js';
-import {BackupService} from './backup.js';
-import {PlcOps} from './plc-ops.js';
-import {MooverUtils} from './utils.js';
-import {Restore} from './restore.js';
-import {handleAndPDSResolver} from './atprotoUtils.js';
-import Alpine from 'alpinejs';
-
-
-window.Migrator = new Migrator();
-window.MissingBlobs = new MissingBlobs();
-window.BackupService = new BackupService();
-window.PlcOps = new PlcOps();
-window.MooverUtils = new MooverUtils();
-window.Restore = new Restore();
-window.handleAndPDSResolver = handleAndPDSResolver;
-
-window.Alpine = Alpine;
-
-Alpine.start();
-
-export {Migrator, MissingBlobs};
-

web/ui-code/src/missingBlobs.js

···
-//I need to condense this code with the rest of PDS MOOver cause it has a lot of overlap
-import {AtpAgent} from '@atproto/api';
-import {handleAndPDSResolver} from './atprotoUtils.js';
-
-
-class MissingBlobs {
-
-  constructor() {
-    this.currentPdsAgent = null;
-    this.oldPdsAgent = null;
-    this.did = null;
-    this.currentPdsUrl = null;
-    this.missingBlobs = [];
-
-  }
-
-  async currentAgentLogin(
-    handle,
-    password,
-    twoFactorCode = null,
-  ) {
-    let {usersDid, pds} = await handleAndPDSResolver(handle);
-    this.did = usersDid;
-    this.currentPdsUrl = pds;
-    const agent = new AtpAgent({
-      service: pds,
-    });
-
-    if (twoFactorCode === null) {
-      await agent.login({identifier: usersDid, password});
-    } else {
-      await agent.login({identifier: usersDid, password: password, authFactorToken: twoFactorCode});
-    }
-
-    this.currentPdsAgent = agent;
-
-    const result = await agent.com.atproto.server.checkAccountStatus();
-    const missingBlobs = await this.currentPdsAgent.com.atproto.repo.listMissingBlobs({
-      limit: 10,
-    });
-    return {accountStatus: result.data, missingBlobsCount: missingBlobs.data.blobs.length};
-  }
-
-  async oldAgentLogin(
-    password,
-    twoFactorCode = null,
-    pdsUrl = null,
-  ) {
-    let oldPds = null;
-
-    if (pdsUrl === null) {
-      const response = await fetch(`https://plc.directory/${this.did}/log`);
-      let auditLog = await response.json();
-      auditLog = auditLog.reverse();
-      let debugCount = 0;
-      for (const entry of auditLog) {
-        console.log(`Loop: ${debugCount++}`);
-        console.log(entry);
-        if (entry.services) {
-          if (entry.services.atproto_pds) {
-            if (entry.services.atproto_pds.type === 'AtprotoPersonalDataServer') {
-              const pds = entry.services.atproto_pds.endpoint;
-              console.log(`Found PDS: ${pds}`);
-              if (pds.toLowerCase() !== this.currentPdsUrl.toLowerCase()) {
-                oldPds = pds;
-                break;
-              }
-            }
-          }
-        }
-      }
-      if (oldPds === null) {
-        throw new Error('Could not find your old PDS');
-      }
-    } else {
-      oldPds = pdsUrl;
-    }
-
-    const agent = new AtpAgent({
-      service: oldPds,
-    });
-
-    if (twoFactorCode === null) {
-      await agent.login({identifier: this.did, password});
-    } else {
-      await agent.login({identifier: this.did, password: password, authFactorToken: twoFactorCode});
-    }
-    this.oldPdsAgent = agent;
-  }
-
-  async migrateMissingBlobs(statusUpdateHandler) {
-    if (this.currentPdsAgent === null) {
-      throw new Error('Current PDS agent is not set');
-    }
-    if (this.oldPdsAgent === null) {
-      throw new Error('Old PDS agent is not set');
-    }
-    statusUpdateHandler('Starting to import blobs...');
-
-    // const currentAccountStatus = await this.currentPdsAgent.com.atproto.server.checkAccountStatus();
-    // let totalMissingBlobs = currentAccountStatus.data.expectedBlobs - currentAccountStatus.data.importedBlobs;
-    let totalMissingBlobs = 0;
-    let missingBlobCursor = undefined;
-    let missingUploadedBlobs = 0;
-
-    do {
-
-      const missingBlobs = await this.currentPdsAgent.com.atproto.repo.listMissingBlobs({
-        cursor: missingBlobCursor,
-        //Test this cause it may be a big update
-        limit: 1000,
-      });
-      totalMissingBlobs += missingBlobs.data.blobs.length;
-
-      for (const recordBlob of missingBlobs.data.blobs) {
-        try {
-
-          const blobRes = await this.oldPdsAgent.com.atproto.sync.getBlob({
-            did: this.did,
-            cid: recordBlob.cid,
-          });
-          let result = await this.currentPdsAgent.com.atproto.repo.uploadBlob(blobRes.data, {
-            encoding: blobRes.headers['content-type'],
-          });
-
-          if (result.status === 429) {
-            statusUpdateHandler(`You are being rate limited. Will need to try again later to get the rest of the blobs. Migrated blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);
-          }
-
-          if (missingUploadedBlobs % 2 === 0) {
-            statusUpdateHandler(`Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs} (The total may increase as we find more)`);
-          }
-          missingUploadedBlobs++;
-        } catch (error) {
-          console.error(error);
-          this.missingBlobs.push(recordBlob.cid);
-        }
-      }
-      missingBlobCursor = missingBlobs.data.cursor;
-    } while (missingBlobCursor);
-
-    const accountStatus = await this.currentPdsAgent.com.atproto.server.checkAccountStatus();
-    const missingBlobs = await this.currentPdsAgent.com.atproto.repo.listMissingBlobs({
-      limit: 10,
-    });
-    return {accountStatus: accountStatus.data, missingBlobsCount: missingBlobs.data.blobs.length};
-
-
-  }
-
-}
-
-export {MissingBlobs};

web/ui-code/src/pdsmoover.js

···
-import {docResolver, fetchPDSMooverDIDWeb, handleResolver} from './atprotoUtils.js';
-import {AtpAgent} from '@atproto/api';
-
-
-function safeStatusUpdate(statusUpdateHandler, status) {
-  if (statusUpdateHandler) {
-    statusUpdateHandler(status);
-  }
-}
-
-
-class Migrator {
-  constructor() {
-    /** @type {AtpAgent} */
-    this.oldAgent = null;
-    /** @type {AtpAgent} */
-    this.newAgent = null;
-    this.missingBlobs = [];
-    //State for reruns
-    this.createNewAccount = true;
-    this.migrateRepo = true;
-    this.migrateBlobs = true;
-    this.migrateMissingBlobs = true;
-    this.migratePrefs = true;
-    this.migratePlcRecord = true;
-  }
-
-  /**
-     * This migrator is pretty cut and dry and makes a few assumptions
-     * 1. You are using the same password between each account
-     * 2. If this command fails for something like oauth 2fa code it throws an error and expects the same values when ran again.
-     * @param {string} oldHandle - The handle you use on your old pds, something like alice.bsky.social
-     * @param {string} password - Your password for your current login. Has to be your real password, no app password. When setting up a new account we reuse it as well for that account
-     * @param {string} newPdsUrl - The new URL for your pds. Like https://coolnewpds.com
-     * @param {string} newEmail - The email you want to use on the new pds (can be the same as the previous one as long as it's not already being used on the new pds)
-     * @param {string} newHandle - The new handle you want, like alice.bsky.social, or if you already have a domain name set as a handle can use it myname.com.
-     * @param {string|null} inviteCode - The invite code you got from the PDS you are migrating to. If null does not include one
-     * @param {function|null} statusUpdateHandler - a function that takes a string used to update the UI. Like (status) => console.log(status)
-     * @param {string|null} twoFactorCode - Optional, but needed if it fails with 2fa required
-     */
-  async migrate(oldHandle, password, newPdsUrl, newEmail, newHandle, inviteCode, statusUpdateHandler = null, twoFactorCode = null) {
-
-    //Copying the handle from bsky website adds some random unicodes on
-    oldHandle = oldHandle.replace('@', '').trim().replace(/[\u202A\u202C\u200E\u200F\u2066-\u2069]/g, '');
-    let oldAgent;
-    let usersDid;
-    //If it's a bsky handle just go with the entryway and let it sort everything
-    if (oldHandle.endsWith('.bsky.social')) {
-      oldAgent = new AtpAgent({service: 'https://bsky.social'});
-      const publicAgent = new AtpAgent({service: 'https://public.api.bsky.app'});
-      const resolveIdentityFromEntryway = await publicAgent.com.atproto.identity.resolveHandle({handle: oldHandle});
-      usersDid = resolveIdentityFromEntryway.data.did;
-
-    } else {
-      //Resolves the did and finds the did document for the old PDS
-      safeStatusUpdate(statusUpdateHandler, 'Resolving old PDS');
-      usersDid = await handleResolver.resolve(oldHandle);
-      const didDoc = await docResolver.resolve(usersDid);
-      safeStatusUpdate(statusUpdateHandler, 'Resolving did document and finding your current PDS URL');
-
-      let oldPds;
-      try {
-        oldPds = didDoc.service.filter(s => s.type === 'AtprotoPersonalDataServer')[0].serviceEndpoint;
-      } catch (error) {
-        console.error(error);
-        throw new Error('Could not find a PDS in the DID document.');
-      }
-
-      oldAgent = new AtpAgent({
-        service: oldPds,
-      });
-
-    }
-
-    safeStatusUpdate(statusUpdateHandler, 'Logging you in to the old PDS');
-    //Login to the old PDS
-    if (twoFactorCode === null) {
-      await oldAgent.login({identifier: oldHandle, password});
-    } else {
-      await oldAgent.login({identifier: oldHandle, password: password, authFactorToken: twoFactorCode});
-    }
-
-    safeStatusUpdate(statusUpdateHandler, 'Checking that the new PDS is an actual PDS (if the url is wrong this takes a while to error out)');
-    const newAgent = new AtpAgent({service: newPdsUrl});
-    const newHostDesc = await newAgent.com.atproto.server.describeServer();
-    if (this.createNewAccount) {
-      const newHostWebDid = newHostDesc.data.did;
-
-      safeStatusUpdate(statusUpdateHandler, 'Creating a new account on the new PDS');
-
-      const createAuthResp = await oldAgent.com.atproto.server.getServiceAuth({
-        aud: newHostWebDid,
-        lxm: 'com.atproto.server.createAccount',
-      });
-      const serviceJwt = createAuthResp.data.token;
-
-      let createAccountRequest = {
-        did: usersDid,
-        handle: newHandle,
-        email: newEmail,
-        password: password,
-      };
-      if (inviteCode) {
-        createAccountRequest.inviteCode = inviteCode;
-      }
-      const createNewAccount = await newAgent.com.atproto.server.createAccount(
-        createAccountRequest,
-        {
-          headers: {authorization: `Bearer ${serviceJwt}`},
-          encoding: 'application/json',
-        });
-
-      if (createNewAccount.data.did !== usersDid.toString()) {
-        throw new Error('Did not create the new account with the same did as the old account');
-      }
-    }
-    safeStatusUpdate(statusUpdateHandler, 'Logging in with the new account');
-
-    await newAgent.login({
-      identifier: usersDid,
-      password: password,
-    });
-
-    if (this.migrateRepo) {
-      safeStatusUpdate(statusUpdateHandler, 'Migrating your repo');
-      const repoRes = await oldAgent.com.atproto.sync.getRepo({did: usersDid});
-      await newAgent.com.atproto.repo.importRepo(repoRes.data, {
-        encoding: 'application/vnd.ipld.car',
-      });
-    }
-
-    let newAccountStatus = await newAgent.com.atproto.server.checkAccountStatus();
-
-    if (this.migrateBlobs) {
-      safeStatusUpdate(statusUpdateHandler, 'Migrating your blobs');
-
-      let blobCursor = undefined;
-      let uploadedBlobs = 0;
-      do {
-        safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);
-
-        const listedBlobs = await oldAgent.com.atproto.sync.listBlobs({
-          did: usersDid,
-          cursor: blobCursor,
-          limit: 100,
-        });
-
-        for (const cid of listedBlobs.data.cids) {
-          try {
-            const blobRes = await oldAgent.com.atproto.sync.getBlob({
-              did: usersDid,
-              cid,
-            });
-            await newAgent.com.atproto.repo.uploadBlob(blobRes.data, {
-              encoding: blobRes.headers['content-type'],
-            });
-            uploadedBlobs++;
-            if (uploadedBlobs % 10 === 0) {
-              safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);
-            }
-          } catch (error) {
-            console.error(error);
-          }
-        }
-        blobCursor = listedBlobs.data.cursor;
-      } while (blobCursor);
-    }
-
-    if (this.migrateMissingBlobs) {
-      newAccountStatus = await newAgent.com.atproto.server.checkAccountStatus();
-      if (newAccountStatus.data.expectedBlobs !== newAccountStatus.data.importedBlobs) {
-        let totalMissingBlobs = newAccountStatus.data.expectedBlobs - newAccountStatus.data.importedBlobs;
-        safeStatusUpdate(statusUpdateHandler, 'Looks like there are some missing blobs. Going to try and upload them now.');
-        //Probably should be shared between main blob uploader, but eh
-        let missingBlobCursor = undefined;
-        let missingUploadedBlobs = 0;
-        do {
-          safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);
-
-          const missingBlobs = await newAgent.com.atproto.repo.listMissingBlobs({
-            cursor: missingBlobCursor,
-            limit: 100,
-          });
-
-          for (const recordBlob of missingBlobs.data.blobs) {
-            try {
-
-              const blobRes = await oldAgent.com.atproto.sync.getBlob({
-                did: usersDid,
-                cid: recordBlob.cid,
-              });
-              await newAgent.com.atproto.repo.uploadBlob(blobRes.data, {
-                encoding: blobRes.headers['content-type'],
-              });
-              if (missingUploadedBlobs % 10 === 0) {
-                safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);
-              }
-              missingUploadedBlobs++;
-            } catch (error) {
-              //TODO silently logging prob should list them so user can manually download
-              console.error(error);
-              this.missingBlobs.push(recordBlob.cid);
-            }
-          }
-          missingBlobCursor = missingBlobs.data.cursor;
-        } while (missingBlobCursor);
-
-      }
-    }
-    if (this.migratePrefs) {
-      const prefs = await oldAgent.app.bsky.actor.getPreferences();
-      await newAgent.app.bsky.actor.putPreferences(prefs.data);
-    }
-
-    this.oldAgent = oldAgent;
-    this.newAgent = newAgent;
-
-    if (this.migratePlcRecord) {
-      await oldAgent.com.atproto.identity.requestPlcOperationSignature();
-      safeStatusUpdate(statusUpdateHandler, 'Please check your email for a PLC token');
-    }
-  }
-
-  /**
-     *  Sign and submits the PLC operation to officially migrate the account
-     * @param {string} token - the PLC token sent in the email. If you're just wanting to run this rerun migrate with all the flags set as false except for migratePlcRecord
-     * @param additionalRotationKeysToAdd {[string]} - additional rotation keys to add in addition to the ones provided by the new PDS.
-     * @returns {Promise<void>}
-     */
-  async signPlcOperation(token, additionalRotationKeysToAdd = []) {
-    const getDidCredentials =
-            await this.newAgent.com.atproto.identity.getRecommendedDidCredentials();
-    const pdsProvidedRotationKeys = getDidCredentials.data.rotationKeys ?? [];
-    // Prepend any additional rotation keys (e.g., user-added keys, newly created key) so they appear above the new PDS rotation key
-    const rotationKeys = [...(additionalRotationKeysToAdd || []), ...pdsProvidedRotationKeys];
-    if (!rotationKeys) {
-      throw new Error('No rotation key provided from the new PDS');
-    }
-    const credentials = {
-      ...getDidCredentials.data,
-      rotationKeys: rotationKeys,
-    };
-
-
-    const plcOp = await this.oldAgent.com.atproto.identity.signPlcOperation({
-      token: token,
-      ...credentials,
-    });
-
-    await this.newAgent.com.atproto.identity.submitPlcOperation({
-      operation: plcOp.data.operation,
-    });
-
-    await this.newAgent.com.atproto.server.activateAccount();
-    await this.oldAgent.com.atproto.server.deactivateAccount({});
-  }
-
-  // Quick and dirty copy and paste of the above to get a fix out to help people without breaking or introducing any bugs to the migration service...hopefully
-  async deactivateOldAccount(oldHandle, oldPassword, statusUpdateHandler = null, twoFactorCode = null) {
-    //Copying the handle from bsky website adds some random unicodes on
-    oldHandle = oldHandle.replace('@', '').trim().replace(/[\u202A\u202C\u200E\u200F\u2066-\u2069]/g, '');
-    let usersDid;
-    //If it's a bsky handle just go with the entryway and let it sort everything
-    if (oldHandle.endsWith('.bsky.social')) {
-      const publicAgent = new AtpAgent({service: 'https://public.api.bsky.app'});
-      const resolveIdentityFromEntryway = await publicAgent.com.atproto.identity.resolveHandle({handle: oldHandle});
-      usersDid = resolveIdentityFromEntryway.data.did;
-    } else {
-      //Resolves the did and finds the did document for the old PDS
-      safeStatusUpdate(statusUpdateHandler, 'Resolving did from handle');
-      usersDid = await handleResolver.resolve(oldHandle);
-    }
-
-    const didDoc = await docResolver.resolve(usersDid);
-    let currentPds;
-    try {
-      currentPds = didDoc.service.filter(s => s.type === 'AtprotoPersonalDataServer')[0].serviceEndpoint;
-    } catch (error) {
-      console.error(error);
-      throw new Error('Could not find a PDS in the DID document.');
-    }
-
-    const plcLogRequest = await fetch(`https://plc.directory/${usersDid}/log`);
-    const plcLog = await plcLogRequest.json();
-    let pdsBeforeCurrent = '';
-    for (const log of plcLog) {
-      try {
-        const pds = log.services.atproto_pds.endpoint;
-        console.log(pds);
-        if (pds.toLowerCase() === currentPds.toLowerCase()) {
-          console.log('Found the PDS before the current one');
-          break;
-        }
-        pdsBeforeCurrent = pds;
-      } catch (e) {
-        console.log(e);
-      }
-    }
-    if (pdsBeforeCurrent === '') {
-      throw new Error('Could not find the PDS before the current one');
-    }
-
-    let oldAgent = new AtpAgent({service: pdsBeforeCurrent});
-    safeStatusUpdate(statusUpdateHandler, `Logging you in to the old PDS: ${pdsBeforeCurrent}`);
-    //Login to the old PDS
-    if (twoFactorCode === null) {
-      await oldAgent.login({identifier: oldHandle, password: oldPassword});
-    } else {
-      await oldAgent.login({identifier: oldHandle, password: oldPassword, authFactorToken: twoFactorCode});
-    }
-    safeStatusUpdate(statusUpdateHandler, 'Checking this isn\'t your current PDS');
-    if (pdsBeforeCurrent === currentPds) {
-      throw new Error('This is your current PDS. Login to your old account username and password');
-    }
-
-    let currentAccountStatus = await oldAgent.com.atproto.server.checkAccountStatus();
-    if (!currentAccountStatus.data.activated) {
-      safeStatusUpdate(statusUpdateHandler, 'All good. Your old account is not activated.');
-    }
-    safeStatusUpdate(statusUpdateHandler, 'Deactivating your OLD account');
-    await oldAgent.com.atproto.server.deactivateAccount({});
-    safeStatusUpdate(statusUpdateHandler, 'Successfully deactivated your OLD account');
-  }
-
-  async signUpForBackupsFromMigration() {
-    // Use a plain fetch POST with atproto-proxy header and bearer from the new agent
-    const didWeb = await fetchPDSMooverDIDWeb(window.location.origin);
-
-    const url = `${this.newAgent.serviceUrl.origin}/xrpc/com.pdsmoover.backup.signUp`;
-
-    const accessJwt = this.newAgent?.session?.accessJwt;
-    if (!accessJwt) {
-      throw new Error('Missing access token for authorization');
-    }
-
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${accessJwt}`,
-        'Content-Type': 'application/json',
-        'Accept': 'application/json',
-        'atproto-proxy': `${didWeb}#repo_backup`,
-      },
-      body: JSON.stringify({}),
-    });
-
-    if (!res.ok) {
-      let bodyText = '';
-      try {
-        bodyText = await res.text();
-      } catch {
-      }
-      throw new Error(`Backup signup failed: ${res.status} ${res.statusText}${bodyText ? ` - ${bodyText}` : ''}`);
-    }
-
-    //No return the success is all that is needed, if there's an error it will throw
-  }
-}
-
-export {Migrator};
-

web/ui-code/src/plc-ops.js

···
-import {defs, normalizeOp} from '@atcute/did-plc';
-import {P256PrivateKey, parsePrivateMultikey, Secp256k1PrivateKey, Secp256k1PrivateKeyExportable} from '@atcute/crypto';
-import * as CBOR from '@atcute/cbor';
-import {fromBase16, toBase64Url} from '@atcute/multibase';
-
-//NOTES
-// Don't forget disputes can check https://github.dev/mary-ext/boat/blob/trunk/src/views/identity/plc-applicator/steps/step1_handle-input.tsx
-//This is if a previous operation should be disputed, it will be a check box on recovery
-
-const PLC_DIRECTORY_URL = 'https://plc.directory';
-
-
-// Helper to base64url-encode JSON
-const jsonToB64Url = (obj) => {
-  const enc = new TextEncoder();
-  const json = JSON.stringify(obj);
-  return toBase64Url(enc.encode(json));
-};
-
-class PlcOps {
-  constructor() {
-
-  }
-
-  //TODO ui
-  // For unvaldiating a record in 72hr window add an advance option input for that cid
-  //that will be the easiest way at launch and just help ppl
-
-  //NEEDS
-  // Function to get current rotation keys
-  // function to create a new key
-  // function to add a new key and save and submit
-  // Can use that same function for signing a recover
-
-  async testSignAServiceAuthToken(did) {
-    //
-    const testPrivateKey = 'z3vLhP9c6gwUUwA4jkyYE9SXifE7wD1f3rVMMLmqBq8TaT2B';
-    let signingKeypair = await this.getKeyPair(testPrivateKey);
-    let test = await this.createANewServiceAuthToken(did, 'did:web:dev.pdsmoover.com', signingKeypair.keypair, 'com.pdsmoover.backup.requestBackup');
-    console.log(test);
-  }
-
-
-  async exampleOfSigningAPLCOPManuallyThatWorks() {
-    //dev keys
-    // New Rotation Key: did:key:zQ3shXuksWLbyTTbWrSJ41qZvR2eyNFGTdbjjG3b2MWRo5cSx
-    // New Private Key: z3vLhP9c6gwUUwA4jkyYE9SXifE7wD1f3rVMMLmqBq8TaT2B
-    const testPrivateKey = 'z3vLhP9c6gwUUwA4jkyYE9SXifE7wD1f3rVMMLmqBq8TaT2B';
-    let signingKeypair = await this.getKeyPair(testPrivateKey);
-    let {lastOperation, base} = await this.getLastPlcOpFromPlc(did);
-    console.log(lastOperation);
-    let {privateKey, publicKey} = await this.createANewSecp256k1();
-    console.log('New Rotation Key:', publicKey);
-    console.log('New Private Key:', privateKey);
-    let newRotationKeys = lastOperation.rotationKeys || [];
-    //Adds the new one to the top
-    newRotationKeys.unshift(publicKey);
-    await this.signAndPublishNewOp(did, signingKeypair.keypair, lastOperation.alsoKnownAs, newRotationKeys, lastOperation.services.atproto_pds.endpoint, lastOperation.verificationMethods.atproto, base.cid);
-
-  }
-
-  async getCurrentRotationKeysForUser(did) {
-    const logs = await this.getPlcAuditLogs(did);
-    const {rotationKeys} = this.getLastPlcOp(logs);
-    return rotationKeys;
-  }
-
-  async getLastPlcOpFromPlc(did) {
-    const logs = await this.getPlcAuditLogs(did);
-    return this.getLastPlcOp(logs);
-  }
-
-  getLastPlcOp(logs) {
-    const lastOp = logs.at(-1);
-    return {lastOperation: normalizeOp(lastOp.operation), base: lastOp};
-  }
-
-
-  async getPlcAuditLogs(did) {
-    const response = await fetch(`${PLC_DIRECTORY_URL}/${did}/log/audit`);
-    if (!response.ok) {
-      throw new Error(`got resposne ${response.status}`);
-    }
-
-    const json = await response.json();
-    return defs.indexedEntryLog.parse(json);
-  }
-
-  /**
-     * Creates a new secp256k1 key that can be used for either rotation or verification key
-     * @returns {Promise<{privateKey: string, publicKey: `did:key:${string}`}>}
-     */
-
-  async createANewSecp256k1() {
-    let keypair = await Secp256k1PrivateKeyExportable.createKeypair();
-    let publicKey = await keypair.exportPublicKey('did');
-    let privateKey = await keypair.exportPrivateKey('multikey');
-    return {
-      privateKey,
-      publicKey
-    };
-  }
-
-
-  /**
-     * Signs a new operation with the provided signing key and submits it
-     * @param did
-     * @param signingRotationKey
-     * @param alsoKnownAs
-     * @param rotationKeys
-     * @param pds
-     * @param verificationKey
-     * @returns {Promise<void>}
-     */
-  async signAndPublishNewOp(did, signingRotationKey, alsoKnownAs, rotationKeys, pds, verificationKey, prev) {
-    const operation = {
-      type: 'plc_operation',
-      // prev: prev!.cid,
-      prev,
-      alsoKnownAs,
-      rotationKeys,
-      services: {
-        atproto_pds: {
-          type: 'AtprotoPersonalDataServer',
-          endpoint: pds
-        }
-      },
-      verificationMethods: {
-        atproto: verificationKey
-      }
-    };
-    const opBytes = CBOR.encode(operation);
-    const sigBytes = await signingRotationKey.sign(opBytes);
-
-    const signature = toBase64Url(sigBytes);
-
-    const signedOperation = {
-      ...operation,
-      sig: signature,
-    };
-
-    await this.pushPlcOperation(did, signedOperation);
-  }
-
-  /**
-     * Takes a multi or hexbased private key and returns a keypair
-     * @param privateKeyString
-     * @param type
-     * @returns {Promise<{type: string, didPublicKey: `did:key:${string}`, keypair: P256PrivateKey|Secp256k1PrivateKey}>}
-     */
-  async getKeyPair(privateKeyString, type = 'p256') {
-    const HEX_REGEX = /^[0-9a-f]+$/i;
-    const MULTIKEY_REGEX = /^z[a-km-zA-HJ-NP-Z1-9]+$/;
-    let keypair = undefined;
-
-    if (HEX_REGEX.test(privateKeyString)) {
-      const privateKeyBytes = fromBase16(privateKeyString);
-
-      switch (type) {
-      case 'p256': {
-        keypair = await P256PrivateKey.importRaw(privateKeyBytes);
-        break;
-      }
-      case 'secp256k1': {
-        keypair = await Secp256k1PrivateKey.importRaw(privateKeyBytes);
-        break;
-      }
-      default: {
-        throw new Error(`unsupported "${type}" type`);
-      }
-      }
-    } else if (MULTIKEY_REGEX.test(privateKeyString)) {
-
-      const match = parsePrivateMultikey(privateKeyString);
-      console.log(match);
-      const privateKeyBytes = match.privateKeyBytes;
-
-      switch (match.type) {
-      case 'p256': {
-        keypair = await P256PrivateKey.importRaw(privateKeyBytes);
-        console.log(keypair);
-        break;
-      }
-      case 'secp256k1': {
-        keypair = await Secp256k1PrivateKey.importRaw(privateKeyBytes);
-        break;
-      }
-      default: {
-        throw new Error(`unsupported "${type}" type`);
-      }
-      }
-    } else {
-      throw new Error('unknown input format');
-    }
-
-    return {
-      type: 'private_key',
-      didPublicKey: await keypair.exportPublicKey('did'),
-      keypair: keypair,
-    };
-  }
-
-  async pushPlcOperation(did, operation) {
-    const response = await fetch(`${PLC_DIRECTORY_URL}/${did}`, {
-      method: 'post',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body: JSON.stringify(operation),
-    });
-
-    const headers = response.headers;
-    if (!response.ok) {
-      const type = headers.get('content-type');
-
-      if (type?.includes('application/json')) {
-        const json = await response.json();
-        if (typeof json === 'object' && json !== null && typeof json.message === 'string') {
-          throw new Error(json.message);
-        }
-      }
-
-      throw new Error(`got http ${response.status} from plc`);
-    }
-  };
-
-
-  /**
-     *
-     * @param iss The user's did
-     * @param aud The did:web, if it's a PDS it's usually from /xrpc/com.atproto.server.describeServer
-     * @param keypair The keypair to sign with only supporting ES256K atm
-     * @param lxm The lxm which is usually com.atproto.server.createAccount for creating a new account
-     * @returns {Promise<string>}
-     */
-  async createANewServiceAuthToken(iss, aud, keypair, lxm) {
-
-
-    // Compute iat/exp defaults (60s window like reference: MINUTE/1e3)
-    const iat = Math.floor(Date.now() / 1e3);
-    const exp = iat + 60;
-
-    // Generate a 16-byte hex jti
-    const jti = (() => {
-      const bytes = new Uint8Array(16);
-      // crypto in browser or node; fall back safely
-      (globalThis.crypto || window.crypto).getRandomValues(bytes);
-      return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
-    })();
-
-
-    // Build header and payload (omit undefined fields)
-    // Just defaulting to ES256K since p256 was not importing on firefox
-    const header = {typ: 'JWT', alg: 'ES256K'};
-    const payload = {};
-    payload.iat = iat;
-    payload.iss = iss;
-    payload.aud = aud;
-    payload.exp = exp;
-    payload.lxm = lxm;
-    payload.jti = jti;
-
-    const headerB64 = jsonToB64Url(header);
-    const payloadB64 = jsonToB64Url(payload);
-    const toSignStr = `${headerB64}.${payloadB64}`;
-
-    // Sign
-    const toSignBytes = new TextEncoder().encode(toSignStr);
-    const sigBytes = await keypair.sign(toSignBytes);
-
-    // Return compact JWS
-    const sigB64 = toBase64Url(sigBytes);
-    return `${toSignStr}.${sigB64}`;
-  }
-
-
-}
-
-
-export {PlcOps};

web/ui-code/src/restore.js

···
-import {handleAndPDSResolver} from './atprotoUtils.js';
-import {PlcOps} from './plc-ops.js';
-import {normalizeOp, Operation} from '@atcute/did-plc';
-import {AtpAgent} from '@atproto/api';
-import {Secp256k1PrivateKeyExportable} from '@atcute/crypto';
-import * as CBOR from '@atcute/cbor';
-import {toBase64Url} from '@atcute/multibase';
-
-class Restore {
-
-  constructor() {
-    /** @type {PlcOps} */
-    this.plcOps = new PlcOps();
-    this.tempVerificationKeypair = null;
-    /** @type {AtpAgent} */
-    this.atpAgent = null;
-    this.recoveryRotationKeyPair = null;
-    //Feature flags
-    this.justRestoreFiles = false;
-  }
-
-  async recover(
-    rotationKey,
-    currentHandle,
-    newPDS,
-    newHandle,
-    newPassword,
-    newEmail,
-    inviteCode,
-    cidToRestoreTo = null,
-    onStatus = null) {
-
-
-    if (onStatus) onStatus('Resolving your handle...');
-
-    let {usersDid} = await handleAndPDSResolver(currentHandle);
-
-    if (onStatus) onStatus('Checking that the new PDS is an actual PDS (if the url is wrong, this takes a while to error out)');
-    this.atpAgent = new AtpAgent({service: newPDS});
-    const newHostDesc = await this.atpAgent.com.atproto.server.describeServer();
-
-
-    //Check to see if the user already has a repo on the new PDS, if they do no reason to try and restore via the plc operations
-    try {
-      await this.atpAgent.com.atproto.repo.describeRepo({repo: usersDid.toString()});
-      //If we got this far and there is a repo on the new PDS with the users did, we can just move on and restore the files
-      this.justRestoreFiles = true;
-
-    } catch (error) {
-      console.error(error);
-      let parsedError = error.error;
-      if (parsedError === 'RepoDeactivated') {
-        //Ideally should mean they already have a repo on the new PDS and we just need to restore the files
-        this.justRestoreFiles = true;
-      }
-      //This is the error we want to see, anything else throw
-      if (parsedError !== 'RepoNotFound') {
-        throw error;
-      }
-    }
-
-    //We need to double check that the new handle has not been taken, if it has we need to throw an error
-    //We care a bit more because we do not want any unnecessary plc ops to be created
-    try {
-      let resolveHandle = await this.atpAgent.com.atproto.identity.resolveHandle({handle: newHandle});
-      if (resolveHandle.data.did === usersDid.toString()) {
-        //Ideally shouldn't get here without the checks above. But we do not need to create a new account or do plc ops. It should already be there
-        this.justRestoreFiles = true;
-      } else {
-        //There is a repo with that name and it's not the users did,
-        throw new Error('The new handle is already taken, please select a different handle');
-      }
-    } catch (error) {
-      // Going to silently log this and just assume the handle has not been taken.
-      console.error(error);
-      if (error.message.startsWith('The new handle')) {
-        //it's not our custom error, so we can just throw it
-        throw error;
-      }
-
-    }
-
-    if (!this.justRestoreFiles) {
-
-      if (onStatus) onStatus('Validating your private rotation key is in the correct format...');
-      this.recoveryRotationKeyPair = await this.plcOps.getKeyPair(rotationKey);
-
-
-      if (onStatus) onStatus('Resolving PlC operation logs...');
-
-      /** @type  {Operation} */
-      let baseOpForSigning = null;
-      let opPrevCid = null;
-
-      //This is for reversals against a rogue plc op and you want to restore to a specific cid in the audit log
-      if (cidToRestoreTo) {
-        let auditLogs = await this.plcOps.getPlcAuditLogs(usersDid);
-        for (const log of auditLogs) {
-          if (log.cid === cidToRestoreTo) {
-            baseOpForSigning = normalizeOp(log.operation);
-            opPrevCid = log.cid;
-            break;
-          }
-        }
-        if (!baseOpForSigning) {
-          throw new Error('Could not find the cid in the audit logs');
-        }
-      } else {
-        let {lastOperation, base} = await this.plcOps.getLastPlcOpFromPlc(usersDid);
-        opPrevCid = base.cid;
-        baseOpForSigning = lastOperation;
-      }
-
-      if (onStatus) onStatus('Preparing to switch to a temp atproto key...');
-      if (this.tempVerificationKeypair == null) {
-        if (onStatus) onStatus('Creating a new temp atproto key...');
-        this.tempVerificationKeypair = await Secp256k1PrivateKeyExportable.createKeypair();
-      }
-      //Just defaulting to the user's recovery key for now. Advance cases will be something else
-      //Maybe just a new ui to edit the PLC doc in a limited capacity, but sinc ethis is a temp plc op i don't think it's needed
-      let tempRotationKeys = [this.recoveryRotationKeyPair.didPublicKey];
-
-      if (onStatus) onStatus('Modifying the PLC OP for recovery...');
-      //A temp plc op for control of the atproto key to create a serviceAuth and new account on the new PDS
-      await this.plcOps.signAndPublishNewOp(
-        usersDid,
-        this.recoveryRotationKeyPair.keypair,
-        baseOpForSigning.alsoKnownAs,
-        tempRotationKeys,
-        newPDS,
-        await this.tempVerificationKeypair.exportPublicKey('did'),
-        opPrevCid);
-
-
-      if (onStatus) onStatus('Creating your new account on the new PDS...');
-      let serviceAuthToken = await this.plcOps.createANewServiceAuthToken(usersDid, newHostDesc.data.did, this.tempVerificationKeypair, 'com.atproto.server.createAccount');
-
-      let createAccountRequest = {
-        did: usersDid,
-        handle: newHandle,
-        email: newEmail,
-        password: newPassword,
-      };
-      if (inviteCode) {
-        createAccountRequest.inviteCode = inviteCode;
-      }
-      const _ = await this.atpAgent.com.atproto.server.createAccount(
-        createAccountRequest,
-        {
-          headers: {authorization: `Bearer ${serviceAuthToken}`},
-          encoding: 'application/json',
-        });
-    }
-
-    await this.atpAgent.login({
-      identifier: usersDid,
-      password: newPassword,
-    });
-
-    if (!this.justRestoreFiles) {
-      //Moving the user offically to the new PDS
-      if (onStatus) onStatus('Signing the papers...');
-      let {base} = await this.plcOps.getLastPlcOpFromPlc(usersDid);
-      await this.signRestorePlcOperation(usersDid, [this.recoveryRotationKeyPair.didPublicKey], base.cid);
-    }
-
-    if (onStatus) onStatus('Success! Restoring your repo...');
-    const pdsMoover = new AtpAgent({service: window.location.origin});
-    const repoRes = await pdsMoover.com.atproto.sync.getRepo({did: usersDid});
-    await this.atpAgent.com.atproto.repo.importRepo(repoRes.data, {
-      encoding: 'application/vnd.ipld.car',
-    });
-
-    if (onStatus) onStatus('Restoring your blobs...');
-
-    //Using the missing endpoint to findout what's missing then the PDS MOOver endpoint to restore
-    let totalMissingBlobs = 0;
-    let missingBlobCursor = undefined;
-    let missingUploadedBlobs = 0;
-
-    do {
-
-      const missingBlobs = await this.atpAgent.com.atproto.repo.listMissingBlobs({
-        cursor: missingBlobCursor,
-        limit: 1000,
-      });
-      totalMissingBlobs += missingBlobs.data.blobs.length;
-
-      for (const recordBlob of missingBlobs.data.blobs) {
-        try {
-
-          const blobRes = await pdsMoover.com.atproto.sync.getBlob({
-            did: usersDid,
-            cid: recordBlob.cid,
-          });
-          let result = await this.atpAgent.com.atproto.repo.uploadBlob(blobRes.data, {
-            encoding: blobRes.headers['content-type'],
-          });
-
-
-          if (missingUploadedBlobs % 2 === 0) {
-            if (onStatus) onStatus(`Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs} (The total may increase as we find more)`);
-          }
-          missingUploadedBlobs++;
-        } catch (error) {
-          console.error(error);
-        }
-      }
-      missingBlobCursor = missingBlobs.data.cursor;
-    } while (missingBlobCursor);
-
-    const accountStatus = await this.atpAgent.com.atproto.server.checkAccountStatus();
-    if (!accountStatus.data.activated) {
-      if (onStatus) onStatus('Activating your account...');
-      await this.atpAgent.com.atproto.server.activateAccount();
-    }
-  }
-
-  async signRestorePlcOperation(usersDid, additionalRotationKeysToAdd = [], prevCid) {
-    const getDidCredentials =
-            await this.atpAgent.com.atproto.identity.getRecommendedDidCredentials();
-    console.log(getDidCredentials);
-
-    const pdsProvidedRotationKeys = getDidCredentials.data.rotationKeys ?? [];
-    // Prepend any additional rotation keys (e.g., user-added keys, newly created key) so they appear above the new PDS rotation key
-    const rotationKeys = [...(additionalRotationKeysToAdd || []), ...pdsProvidedRotationKeys];
-    if (!rotationKeys) {
-      throw new Error('No rotation key provided from the new PDS');
-    }
-    const plcOpToSubmit = {
-      type: 'plc_operation',
-      ...getDidCredentials.data,
-      prev: prevCid,
-      rotationKeys: rotationKeys,
-    };
-
-
-    const opBytes = CBOR.encode(plcOpToSubmit);
-    const sigBytes = await this.recoveryRotationKeyPair.keypair.sign(opBytes);
-
-    const signature = toBase64Url(sigBytes);
-
-    const signedOperation = {
-      ...plcOpToSubmit,
-      sig: signature,
-    };
-    
-    await this.plcOps.pushPlcOperation(usersDid, signedOperation);
-    await this.atpAgent.com.atproto.server.activateAccount();
-
-  }
-}
-
-export {Restore};

web/ui-code/src/utils.js

···
-class MooverUtils {
-  formatDate(value) {
-    if (!value) return '—';
-    try {
-      const d = new Date(value);
-      return d.toLocaleString();
-    } catch (err) {
-      console.error(err);
-      return String(value);
-    }
-  }
-
-  formatBytes(bytes) {
-    if (bytes == null) return '—';
-    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-    let i = 0;
-    let v = Number(bytes);
-    while (v >= 1024 && i < units.length - 1) {
-      v /= 1024;
-      i++;
-    }
-    return v.toFixed(1) + ' ' + units[i];
-  }
-
-}
-
-
-export {MooverUtils};

web/ui-code/vite.config.js

···
-import {defineConfig} from 'vite';
-import rustVitePlugin from 'vite-rs-plugin';
-
-
-export default defineConfig({
-  port: 5173,
-  plugins: [
-    rustVitePlugin({
-      refresh: './src/**.*',
-      entrypoints: [
-        'src/main.js',
-        'src/pdsmoover.js',
-        'src/missingBlobs.js',
-        'src/atprotoUtils.js',
-        'src/backup.js',
-      ],
-      assetsEndpoint: '/',
-    })
-  ],
-  build: {
-    rollupOptions: {
-      input: ['index.html'],
-    },
-  },
-  // Uncomment this section if you're going to use `start_dev_server` in Rust:
-  // server: {
-  //     hmr: {
-  //         port: 21012,
-  //     },
-  // },
-});