shieldcortex 4.17.0 → 4.18.1

package/dist/api/routes/sessions.js

@@ -13,9 +13,12 @@
  * Pagination cap chosen to match `routes/memories.ts`: 200 max for lists,
  * 500 max for the event stream (replay needs more events at once).
  */
+import { homedir, tmpdir } from 'os';
+import { isAbsolute, join, normalize, resolve, sep } from 'path';
 import { getDatabase } from '../../database/init.js';
 import { getTimeline } from '../../sessions/timeline.js';
 import { importJsonlTranscript } from '../../sessions/import-jsonl.js';
+import { expandGlob, isGlobPattern } from '../../sessions/glob.js';
 const SESSIONS_DEFAULT_LIMIT = 50;
 const SESSIONS_MAX_LIMIT = 200;
 const EVENTS_DEFAULT_LIMIT = 100;
@@ -133,16 +136,79 @@ export function registerSessionRoutes(app, requireNotLocked) {
             res.status(500).json({ error: err.message });
         }
     });
-    // ── POST /api/sessions/import-jsonl — body: { path } ────────────────
-    app.post('/api/sessions/import-jsonl', requireNotLocked, (req, res) => {
+    // ── POST /api/sessions/import-jsonl ────────────────────────────────
+    //
+    // Body forms:
+    //   { path: "/abs/path/to/file.jsonl" }  — import one file
+    //   { path: "/glob/pattern/*.jsonl" }    — import all matching files
+    //   { } or { path: null }                — default: ~/.claude/projects/**/*.jsonl
+    //
+    // Default glob exists so the dashboard's "Import JSONL" button has a
+    // useful zero-arg action. The CLI exposes the same behaviour.
+    app.post('/api/sessions/import-jsonl', requireNotLocked, async (req, res) => {
         try {
             const body = (req.body ?? {});
-            if (typeof body.path !== 'string' || body.path.length === 0) {
-                res.status(400).json({ error: 'path required (string)' });
+            const explicit = typeof body.path === 'string' && body.path.length > 0 ? body.path : null;
+            const target = explicit ?? join(homedir(), '.claude', 'projects', '**', '*.jsonl');
+            let files;
+            try {
+                files = await resolveImportFiles(target);
+            }
+            catch (err) {
+                // Path-traversal rejection from resolveImportFiles → 400 (caller error),
+                // not 500 (server bug). Any other error rethrows.
+                if (err instanceof Error && /must be under/i.test(err.message)) {
+                    res.status(400).json({ error: err.message });
+                    return;
+                }
+                throw err;
+            }
+            if (files.length === 0) {
+                res.status(404).json({ error: `no JSONL files matched: ${target}` });
+                return;
+            }
+            let eventCount = 0;
+            let skipped = 0;
+            let malformed = 0;
+            let imported = 0;
+            let failed = 0;
+            let lastSessionId = null;
+            const errors = [];
+            for (const file of files) {
+                try {
+                    const r = importJsonlTranscript(file);
+                    eventCount += r.eventCount;
+                    skipped += r.skipped;
+                    malformed += r.malformed;
+                    if (r.sessionId)
+                        lastSessionId = r.sessionId;
+                    imported++;
+                }
+                catch (err) {
+                    failed++;
+                    errors.push({ path: file, error: err.message });
+                }
+            }
+            // Special case: a single literal path that doesn't exist → 404. The
+            // glob path already 404'd above when nothing matched; this covers
+            // the "user typed a wrong path" UX.
+            if (files.length === 1 &&
+                imported === 0 &&
+                errors.length === 1 &&
+                /not found|ENOENT/i.test(errors[0].error)) {
+                res.status(404).json({ error: errors[0].error });
                 return;
             }
-            const result = importJsonlTranscript(body.path);
-            res.json(result);
+            res.json({
+                filesMatched: files.length,
+                filesImported: imported,
+                filesFailed: failed,
+                eventCount,
+                skipped,
+                malformed,
+                sessionId: files.length === 1 ? lastSessionId : null,
+                errors: errors.slice(0, 10), // cap at 10 to keep response small
+            });
         }
         catch (err) {
             const message = err.message;
@@ -151,3 +217,59 @@ export function registerSessionRoutes(app, requireNotLocked) {
         }
     });
 }
+/**
+ * Resolve `target` into a list of absolute file paths, ensuring every
+ * result is rooted under a user-trusted directory. The dashboard binds to
+ * `localhost` by default, but constraining imports is a useful
+ * defence-in-depth measure when the dashboard is exposed via a tunnel,
+ * docker port-map, or a careless reverse proxy. A stray POST with
+ * `{ path: "/etc/secret.jsonl" }` should never read that file.
+ *
+ * Allowed roots:
+ *   - the user's home directory (where `~/.claude/projects/...` lives)
+ *   - the OS temp directory (where ad-hoc downloads + the test suite write)
+ *
+ * Both are per-user trust domains. Symlinks that point outside slip past
+ * this check because we don't `realpath()` for perf reasons — the user
+ * owns these trees, so a hostile symlink is a separate threat model.
+ */
+async function resolveImportFiles(target) {
+    const roots = trustedRoots();
+    // Expand `~` then make absolute. `path.normalize` collapses `..` so a
+    // pattern like `~/../etc/passwd` resolves to `/etc/passwd` *before* the
+    // under-root check below catches it.
+    const expanded = expandHome(target, homedir());
+    const absolute = isAbsolute(expanded) ? expanded : resolve(process.cwd(), expanded);
+    const normalized = normalize(absolute);
+    if (!isUnderTrustedRoot(normalized, roots)) {
+        throw new Error(`path must be under home or temp directory: ${target}`);
+    }
+    if (!isGlobPattern(normalized))
+        return [normalized];
+    // Defence in depth: `**` walks symlinked subtrees, so re-filter the
+    // expansion. A symlink that escapes the trusted roots gets dropped here.
+    return expandGlob(normalized).filter((p) => isUnderTrustedRoot(normalize(p), roots));
+}
+function trustedRoots() {
+    // Deduplicate — on some macOS configs `tmpdir()` is a subdir of `homedir()`.
+    const seen = new Set();
+    const entries = [];
+    for (const root of [homedir(), tmpdir()]) {
+        const n = normalize(root);
+        if (seen.has(n))
+            continue;
+        seen.add(n);
+        entries.push({ root: n, withSep: n.endsWith(sep) ? n : n + sep });
+    }
+    return { entries };
+}
+function isUnderTrustedRoot(p, roots) {
+    return roots.entries.some((r) => p === r.root || p.startsWith(r.withSep));
+}
+function expandHome(p, home) {
+    if (p === '~')
+        return home;
+    if (p.startsWith('~/') || p.startsWith('~\\'))
+        return join(home, p.slice(2));
+    return p;
+}

package/dist/cli/import-jsonl.js

@@ -9,10 +9,10 @@
  * Initialises the DB before importing so the call works from any cwd
  * (the importer relies on the singleton `getDatabase()`).
  */
-import { glob } from 'fs/promises';
 import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync } from 'fs';
+import { expandGlob, isGlobPattern } from '../sessions/glob.js';
 export async function handleImportJsonlCommand(args) {
     if (args.includes('--help') || args.includes('-h')) {
         printHelp();
@@ -74,15 +74,10 @@ Examples:
 `);
 }
 async function resolveFiles(target) {
-    // No glob characters → treat as literal path
-    if (!/[*?[\]]/.test(target)) {
+    if (!isGlobPattern(target)) {
         if (!existsSync(target))
             return [];
         return [target];
     }
-    const matches = [];
-    for await (const entry of glob(target)) {
-        matches.push(entry);
-    }
-    return matches.sort();
+    return expandGlob(target).sort();
 }

package/dist/sessions/glob.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Minimal portable glob expansion for the session-capture import flow.
+ *
+ * Node 22 added `fs.promises.glob`, but ShieldCortex's `engines.node`
+ * still declares `>=18.0.0` — using fs/promises.glob would break the
+ * CI matrix (Node 20) and any production deployment running an LTS
+ * earlier than 22. This module implements the narrow subset of glob
+ * semantics the importer actually needs:
+ *
+ *   - Literal paths (no wildcards) — return as-is, caller checks existence.
+ *   - Shell wildcards `*` `?` `[]` within a single directory segment.
+ *   - `**` for any-depth recursion (only between `/`-separated segments;
+ *     `**` inside a filename is treated as a regular `*` `*`).
+ *
+ * No braces, no extglob, no negation. The JSONL importer doesn't need
+ * those and pulling in a full glob package would inflate the install
+ * footprint for a single feature.
+ */
+export interface ExpandGlobOptions {
+    /**
+     * Cap on the number of returned matches. Stops walking once hit so
+     * pathological globs against `/` don't lock up the API process.
+     */
+    maxMatches?: number;
+}
+/**
+ * Returns `true` when the pattern contains any glob metacharacter the
+ * walker treats specially. Used by callers to short-circuit literal
+ * paths and skip the walker entirely.
+ */
+export declare function isGlobPattern(pattern: string): boolean;
+/**
+ * Expand a glob pattern to absolute file paths. Synchronous because
+ * the importer's callsites are already synchronous and the result is
+ * always small enough that I/O is not the bottleneck (sessions live
+ * on local disk under `~/.claude/projects/`).
+ */
+export declare function expandGlob(pattern: string, options?: ExpandGlobOptions): string[];

package/dist/sessions/glob.js

@@ -0,0 +1,183 @@
+/**
+ * Minimal portable glob expansion for the session-capture import flow.
+ *
+ * Node 22 added `fs.promises.glob`, but ShieldCortex's `engines.node`
+ * still declares `>=18.0.0` — using fs/promises.glob would break the
+ * CI matrix (Node 20) and any production deployment running an LTS
+ * earlier than 22. This module implements the narrow subset of glob
+ * semantics the importer actually needs:
+ *
+ *   - Literal paths (no wildcards) — return as-is, caller checks existence.
+ *   - Shell wildcards `*` `?` `[]` within a single directory segment.
+ *   - `**` for any-depth recursion (only between `/`-separated segments;
+ *     `**` inside a filename is treated as a regular `*` `*`).
+ *
+ * No braces, no extglob, no negation. The JSONL importer doesn't need
+ * those and pulling in a full glob package would inflate the install
+ * footprint for a single feature.
+ */
+import { readdirSync, statSync } from 'fs';
+import { join, sep, isAbsolute } from 'path';
+import { homedir } from 'os';
+const DEFAULT_MAX_MATCHES = 10_000;
+/**
+ * Returns `true` when the pattern contains any glob metacharacter the
+ * walker treats specially. Used by callers to short-circuit literal
+ * paths and skip the walker entirely.
+ */
+export function isGlobPattern(pattern) {
+    return /[*?[\]]/.test(pattern);
+}
+/**
+ * Expand a glob pattern to absolute file paths. Synchronous because
+ * the importer's callsites are already synchronous and the result is
+ * always small enough that I/O is not the bottleneck (sessions live
+ * on local disk under `~/.claude/projects/`).
+ */
+export function expandGlob(pattern, options = {}) {
+    const max = options.maxMatches ?? DEFAULT_MAX_MATCHES;
+    const expanded = expandHome(pattern);
+    if (!isGlobPattern(expanded)) {
+        return [expanded];
+    }
+    const segments = expanded.split(/[\\/]+/);
+    // Determine the literal prefix — everything up to the first segment
+    // that has a wildcard. Walking starts from there.
+    let prefix = isAbsolute(expanded) ? sep : '';
+    let i = 0;
+    for (; i < segments.length; i++) {
+        if (isGlobPattern(segments[i]))
+            break;
+        prefix = prefix === sep ? sep + segments[i] : prefix ? join(prefix, segments[i]) : segments[i];
+    }
+    if (prefix === '')
+        prefix = '.';
+    const remaining = segments.slice(i);
+    const matches = [];
+    walk(prefix, remaining, matches, max);
+    return matches.sort();
+}
+/** Recursive matcher. */
+function walk(currentDir, segments, out, max) {
+    if (out.length >= max)
+        return;
+    if (segments.length === 0)
+        return;
+    const [head, ...rest] = segments;
+    // `**` — match any number of directory levels (including zero).
+    if (head === '**') {
+        // Zero levels: continue at currentDir with `rest`.
+        walk(currentDir, rest, out, max);
+        // One-or-more: recurse into every subdirectory with the same `**`.
+        let entries = [];
+        try {
+            entries = readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (out.length >= max)
+                return;
+            if (entry.isDirectory()) {
+                walk(join(currentDir, String(entry.name)), segments, out, max);
+            }
+        }
+        return;
+    }
+    const regex = segmentToRegex(head);
+    const isLastSegment = rest.length === 0;
+    let entries = [];
+    try {
+        entries = readdirSync(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (out.length >= max)
+            return;
+        const name = String(entry.name);
+        if (!regex.test(name))
+            continue;
+        const full = join(currentDir, name);
+        if (isLastSegment) {
+            // Only files match a leaf glob — directories aren't useful for the importer.
+            if (entry.isFile())
+                out.push(full);
+            else if (entry.isSymbolicLink()) {
+                // Resolve symlinks lazily — a broken link just gets skipped.
+                try {
+                    if (statSync(full).isFile())
+                        out.push(full);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        else if (entry.isDirectory() || entry.isSymbolicLink()) {
+            walk(full, rest, out, max);
+        }
+    }
+}
+/** Convert a single shell-glob path segment to a regex. */
+function segmentToRegex(segment) {
+    let pattern = '^';
+    let inCharClass = false;
+    for (let i = 0; i < segment.length; i++) {
+        const c = segment[i];
+        if (inCharClass) {
+            if (c === ']') {
+                inCharClass = false;
+                pattern += ']';
+            }
+            else if (c === '\\') {
+                pattern += '\\\\';
+            }
+            else {
+                pattern += escapeForRegex(c);
+            }
+            continue;
+        }
+        switch (c) {
+            case '*':
+                pattern += '[^/\\\\]*';
+                break;
+            case '?':
+                pattern += '[^/\\\\]';
+                break;
+            case '[':
+                inCharClass = true;
+                pattern += '[';
+                break;
+            case '.':
+            case '+':
+            case '(':
+            case ')':
+            case '{':
+            case '}':
+            case '|':
+            case '^':
+            case '$':
+                pattern += '\\' + c;
+                break;
+            default:
+                pattern += c;
+        }
+    }
+    pattern += '$';
+    return new RegExp(pattern);
+}
+function escapeForRegex(c) {
+    return /[.*+?^${}()|[\]\\]/.test(c) ? '\\' + c : c;
+}
+/** Expand a leading `~` to the user's home directory. */
+function expandHome(p) {
+    if (p === '~')
+        return homedir();
+    if (p.startsWith('~/') || p.startsWith('~\\')) {
+        return join(homedir(), p.slice(2));
+    }
+    return p;
+}

package/dist/sessions/import-jsonl.d.ts

@@ -75,11 +75,15 @@ export interface ImportResult {
  */
 export declare function parseTranscriptLine(line: unknown): SessionEventInput[];
 /**
- * Import one JSONL file. Wraps the whole import in a single transaction
- * so a mid-file error rolls back cleanly — better-sqlite3's transaction
- * helper restores DB state if the callback throws. Malformed lines do
- * NOT throw — they're counted and skipped so a single bad row never
- * blocks the rest of the file.
+ * Import one JSONL file. Streams the file in 64 KB chunks via `readSync`
+ * and a `StringDecoder` (which handles UTF-8 sequences that span chunk
+ * boundaries) so a 500 MB transcript archive doesn't load into a single
+ * string. Parsed rows flush to SQLite in {@link FLUSH_BATCH_ROWS}-sized
+ * transactional batches.
+ *
+ * Malformed lines do NOT throw — they're counted and skipped so a single
+ * bad row never blocks the rest of the file. Idempotent on re-import via
+ * the `INSERT OR IGNORE` + `idx_session_events_dedupe` UNIQUE index.
  */
 export declare function importJsonlTranscript(path: string): ImportResult;
 export {};

package/dist/sessions/import-jsonl.js

@@ -28,7 +28,8 @@
  *   - Things we WILL preserve: prompts, assistant text, tool name +
  *     args + result, and timestamps.
  */
-import { readFileSync, existsSync } from 'fs';
+import { openSync, readSync, closeSync, existsSync } from 'fs';
+import { StringDecoder } from 'string_decoder';
 import { createHash } from 'crypto';
 import { getDatabase } from '../database/init.js';
 /**
@@ -122,27 +123,57 @@ const INSERT_OR_IGNORE_SQL = `
     (session_id, project, ts, kind, actor, payload, duration_ms, audit_id, content_hash)
   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
 `;
+/** 64 KB read chunks — small enough to bound peak memory on huge transcripts, big enough to keep syscall overhead negligible. */
+const READ_CHUNK_BYTES = 64 * 1024;
 /**
- * Import one JSONL file. Wraps the whole import in a single transaction
- * so a mid-file error rolls back cleanly — better-sqlite3's transaction
- * helper restores DB state if the callback throws. Malformed lines do
- * NOT throw — they're counted and skipped so a single bad row never
- * blocks the rest of the file.
+ * Flush rows to disk in transaction batches of this size. The full file is
+ * NOT held in memory; instead we keep at most one chunk-worth of parsed
+ * rows pending. Mid-file failure leaves earlier chunks committed, which is
+ * fine because `INSERT OR IGNORE` makes a re-run idempotent.
+ */
+const FLUSH_BATCH_ROWS = 2000;
+/**
+ * Import one JSONL file. Streams the file in 64 KB chunks via `readSync`
+ * and a `StringDecoder` (which handles UTF-8 sequences that span chunk
+ * boundaries) so a 500 MB transcript archive doesn't load into a single
+ * string. Parsed rows flush to SQLite in {@link FLUSH_BATCH_ROWS}-sized
+ * transactional batches.
+ *
+ * Malformed lines do NOT throw — they're counted and skipped so a single
+ * bad row never blocks the rest of the file. Idempotent on re-import via
+ * the `INSERT OR IGNORE` + `idx_session_events_dedupe` UNIQUE index.
  */
 export function importJsonlTranscript(path) {
     if (!existsSync(path)) {
         throw new Error(`JSONL transcript not found: ${path}`);
     }
-    const raw = readFileSync(path, 'utf-8');
-    const lines = raw.split(/\r?\n/);
-    const rows = [];
+    const db = getDatabase();
+    const stmt = db.prepare(INSERT_OR_IGNORE_SQL);
+    const countStmt = db.prepare('SELECT COUNT(*) AS c FROM session_events');
+    const flush = db.transaction((batch) => {
+        for (const row of batch) {
+            stmt.run(row.session_id, row.project ?? null, row.ts, row.kind, row.actor ?? null, typeof row.payload === 'string' ? row.payload : JSON.stringify(row.payload ?? null), row.duration_ms ?? null, row.audit_id ?? null, row.content_hash);
+        }
+    });
     let sessionId = null;
+    let eventCount = 0;
     let skipped = 0;
     let malformed = 0;
-    for (const rawLine of lines) {
-        const trimmed = rawLine.trim();
+    let inserted = 0;
+    const pending = [];
+    const drain = () => {
+        if (pending.length === 0)
+            return;
+        const before = countStmt.get().c;
+        flush(pending);
+        const after = countStmt.get().c;
+        inserted += after - before;
+        pending.length = 0;
+    };
+    const processLine = (line) => {
+        const trimmed = line.trim();
         if (trimmed.length === 0)
-            continue; // blank lines aren't skipped — they're just whitespace
+            return; // blank — not counted as skipped
         let parsed;
         try {
             parsed = JSON.parse(trimmed);
@@ -150,44 +181,67 @@ export function importJsonlTranscript(path) {
         catch {
             malformed++;
             skipped++;
-            continue;
+            return;
         }
         const events = parseTranscriptLine(parsed);
         if (events.length === 0) {
             skipped++;
-            continue;
+            return;
         }
         if (sessionId === null && events[0]?.session_id) {
             sessionId = events[0].session_id;
         }
         for (const event of events) {
-            rows.push({
-                ...event,
-                content_hash: hashEvent(event.kind, event.payload),
-            });
+            pending.push({ ...event, content_hash: hashEvent(event.kind, event.payload) });
+            eventCount++;
+        }
+    };
+    const fd = openSync(path, 'r');
+    try {
+        const buf = Buffer.alloc(READ_CHUNK_BYTES);
+        const decoder = new StringDecoder('utf8');
+        let leftover = '';
+        let position = 0;
+        while (true) {
+            const bytesRead = readSync(fd, buf, 0, READ_CHUNK_BYTES, position);
+            if (bytesRead === 0)
+                break;
+            position += bytesRead;
+            // StringDecoder buffers partial UTF-8 sequences across chunk boundaries.
+            const text = leftover + decoder.write(buf.subarray(0, bytesRead));
+            const lastNewline = text.lastIndexOf('\n');
+            if (lastNewline === -1) {
+                leftover = text;
+                continue;
+            }
+            const complete = text.slice(0, lastNewline);
+            leftover = text.slice(lastNewline + 1);
+            for (const rawLine of complete.split('\n')) {
+                processLine(rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine);
+            }
+            if (pending.length >= FLUSH_BATCH_ROWS)
+                drain();
+        }
+        // Anything decoder still has buffered (impossible for valid UTF-8, but
+        // handle the malformed-bytes-at-EOF case gracefully).
+        const tail = leftover + decoder.end();
+        if (tail.length > 0) {
+            for (const rawLine of tail.split('\n')) {
+                processLine(rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine);
+            }
         }
     }
-    if (rows.length === 0) {
-        return { sessionId, eventCount: 0, skipped, malformed };
+    finally {
+        closeSync(fd);
     }
-    const db = getDatabase();
-    const stmt = db.prepare(INSERT_OR_IGNORE_SQL);
-    const before = db.prepare('SELECT COUNT(*) AS c FROM session_events').get().c;
-    const tx = db.transaction((batch) => {
-        for (const row of batch) {
-            stmt.run(row.session_id, row.project ?? null, row.ts, row.kind, row.actor ?? null, typeof row.payload === 'string' ? row.payload : JSON.stringify(row.payload ?? null), row.duration_ms ?? null, row.audit_id ?? null, row.content_hash);
-        }
-    });
-    tx(rows);
-    const after = db.prepare('SELECT COUNT(*) AS c FROM session_events').get().c;
-    const inserted = after - before;
+    drain();
     // `eventCount` reflects the total events parsed from this file regardless
-    // of whether the dedupe index dropped them. Caller can compare to
-    // `inserted` (via row count diff) to see how many were duplicates.
+    // of whether the dedupe index dropped them. Duplicates surface in `skipped`
+    // so callers see one consistent "anything not inserted" tally.
     return {
         sessionId,
-        eventCount: rows.length,
-        skipped: skipped + (rows.length - inserted),
+        eventCount,
+        skipped: skipped + (eventCount - inserted),
         malformed,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "4.17.0",
+  "version": "4.18.1",
   "description": "Trustworthy memory and security for AI agents. Recall debugging, review queue, OpenClaw session capture, and memory poisoning defence for Claude Code, Codex, OpenClaw, LangChain, and MCP agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/plugins/openclaw/dist/openclaw.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "shieldcortex-realtime",
-  "version": "4.17.0",
+  "version": "4.18.1",
   "name": "ShieldCortex Real-time Scanner",
   "description": "Real-time defence scanning on LLM input, memory extraction on LLM output, and active tool call interception with approval gating.",
   "kind": null,

package/dashboard/.next/standalone/dashboard/.next/server/chunks/ssr/[root-of-the-server]__521be65c._.js

@@ -1,3 +0,0 @@
-module.exports=[18622,(a,b,c)=>{b.exports=a.x("next/dist/compiled/next-server/app-page-turbo.runtime.prod.js",()=>require("next/dist/compiled/next-server/app-page-turbo.runtime.prod.js"))},14865,(a,b,c)=>{"use strict";b.exports=a.r(18622)},16306,(a,b,c)=>{"use strict";b.exports=a.r(14865).vendored["react-ssr"].ReactJsxRuntime},98419,(a,b,c)=>{"use strict";b.exports=a.r(14865).vendored["react-ssr"].React},17878,a=>{"use strict";var b=a.i(16306),c=a.i(15896),d=a.i(30112),e=a.i(98416),f=a.i(16347),g=class extends f.Subscribable{constructor(a={}){super(),this.config=a,this.#a=new Map}#a;build(a,b,e){let f=b.queryKey,g=b.queryHash??(0,c.hashQueryKeyByOptions)(f,b),h=this.get(g);return h||(h=new d.Query({client:a,queryKey:f,queryHash:g,options:a.defaultQueryOptions(b),state:e,defaultOptions:a.getQueryDefaults(f)}),this.add(h)),h}add(a){this.#a.has(a.queryHash)||(this.#a.set(a.queryHash,a),this.notify({type:"added",query:a}))}remove(a){let b=this.#a.get(a.queryHash);b&&(a.destroy(),b===a&&this.#a.delete(a.queryHash),this.notify({type:"removed",query:a}))}clear(){e.notifyManager.batch(()=>{this.getAll().forEach(a=>{this.remove(a)})})}get(a){return this.#a.get(a)}getAll(){return[...this.#a.values()]}find(a){let b={exact:!0,...a};return this.getAll().find(a=>(0,c.matchQuery)(b,a))}findAll(a={}){let b=this.getAll();return Object.keys(a).length>0?b.filter(b=>(0,c.matchQuery)(a,b)):b}notify(a){e.notifyManager.batch(()=>{this.listeners.forEach(b=>{b(a)})})}onFocus(){e.notifyManager.batch(()=>{this.getAll().forEach(a=>{a.onFocus()})})}onOnline(){e.notifyManager.batch(()=>{this.getAll().forEach(a=>{a.onOnline()})})}},h=a.i(46674),i=f,j=class extends i.Subscribable{constructor(a={}){super(),this.config=a,this.#b=new Set,this.#c=new Map,this.#d=0}#b;#c;#d;build(a,b,c){let d=new h.Mutation({client:a,mutationCache:this,mutationId:++this.#d,options:a.defaultMutationOptions(b),state:c});return this.add(d),d}add(a){this.#b.add(a);let b=k(a);if("string"==typeof b){let c=this.#c.get(b);c?c.push(a):this.#c.set(b,[a])}this.notify({type:"added",mutation:a})}remove(a){if(this.#b.delete(a)){let b=k(a);if("string"==typeof b){let c=this.#c.get(b);if(c)if(c.length>1){let b=c.indexOf(a);-1!==b&&c.splice(b,1)}else c[0]===a&&this.#c.delete(b)}}this.notify({type:"removed",mutation:a})}canRun(a){let b=k(a);if("string"!=typeof b)return!0;{let c=this.#c.get(b),d=c?.find(a=>"pending"===a.state.status);return!d||d===a}}runNext(a){let b=k(a);if("string"!=typeof b)return Promise.resolve();{let c=this.#c.get(b)?.find(b=>b!==a&&b.state.isPaused);return c?.continue()??Promise.resolve()}}clear(){e.notifyManager.batch(()=>{this.#b.forEach(a=>{this.notify({type:"removed",mutation:a})}),this.#b.clear(),this.#c.clear()})}getAll(){return Array.from(this.#b)}find(a){let b={exact:!0,...a};return this.getAll().find(a=>(0,c.matchMutation)(b,a))}findAll(a={}){return this.getAll().filter(b=>(0,c.matchMutation)(a,b))}notify(a){e.notifyManager.batch(()=>{this.listeners.forEach(b=>{b(a)})})}resumePausedMutations(){let a=this.getAll().filter(a=>a.state.isPaused);return e.notifyManager.batch(()=>Promise.all(a.map(a=>a.continue().catch(c.noop))))}};function k(a){return a.options.scope?.id}var l=a.i(7903),m=a.i(59643);function n(a){return{onFetch:(b,d)=>{let e=b.options,f=b.fetchOptions?.meta?.fetchMore?.direction,g=b.state.data?.pages||[],h=b.state.data?.pageParams||[],i={pages:[],pageParams:[]},j=0,k=async()=>{let d=!1,k=(0,c.ensureQueryFn)(b.options,b.fetchOptions),l=async(a,e,f)=>{let g;if(d)return Promise.reject();if(null==e&&a.pages.length)return Promise.resolve(a);let h=(g={client:b.client,queryKey:b.queryKey,pageParam:e,direction:f?"backward":"forward",meta:b.options.meta},(0,c.addConsumeAwareSignal)(g,()=>b.signal,()=>d=!0),g),i=await k(h),{maxPages:j}=b.options,l=f?c.addToStart:c.addToEnd;return{pages:l(a.pages,i,j),pageParams:l(a.pageParams,e,j)}};if(f&&g.length){let a="backward"===f,b={pages:g,pageParams:h},c=(a?function(a,{pages:b,pageParams:c}){return b.length>0?a.getPreviousPageParam?.(b[0],b,c[0],c):void 0}:o)(e,b);i=await l(b,c,a)}else{let b=a??g.length;do{let a=0===j?h[0]??e.initialPageParam:o(e,i);if(j>0&&null==a)break;i=await l(i,a),j++}while(j<b)}return i};b.options.persister?b.fetchFn=()=>b.options.persister?.(k,{client:b.client,queryKey:b.queryKey,meta:b.options.meta,signal:b.signal},d):b.fetchFn=k}}}function o(a,{pages:b,pageParams:c}){let d=b.length-1;return b.length>0?a.getNextPageParam(b[d],b,c[d],c):void 0}var p=class{#e;#f;#g;#h;#i;#j;#k;#l;constructor(a={}){this.#e=a.queryCache||new g,this.#f=a.mutationCache||new j,this.#g=a.defaultOptions||{},this.#h=new Map,this.#i=new Map,this.#j=0}mount(){this.#j++,1===this.#j&&(this.#k=l.focusManager.subscribe(async a=>{a&&(await this.resumePausedMutations(),this.#e.onFocus())}),this.#l=m.onlineManager.subscribe(async a=>{a&&(await this.resumePausedMutations(),this.#e.onOnline())}))}unmount(){this.#j--,0===this.#j&&(this.#k?.(),this.#k=void 0,this.#l?.(),this.#l=void 0)}isFetching(a){return this.#e.findAll({...a,fetchStatus:"fetching"}).length}isMutating(a){return this.#f.findAll({...a,status:"pending"}).length}getQueryData(a){let b=this.defaultQueryOptions({queryKey:a});return this.#e.get(b.queryHash)?.state.data}ensureQueryData(a){let b=this.defaultQueryOptions(a),d=this.#e.build(this,b),e=d.state.data;return void 0===e?this.fetchQuery(a):(a.revalidateIfStale&&d.isStaleByTime((0,c.resolveStaleTime)(b.staleTime,d))&&this.prefetchQuery(b),Promise.resolve(e))}getQueriesData(a){return this.#e.findAll(a).map(({queryKey:a,state:b})=>[a,b.data])}setQueryData(a,b,d){let e=this.defaultQueryOptions({queryKey:a}),f=this.#e.get(e.queryHash),g=f?.state.data,h=(0,c.functionalUpdate)(b,g);if(void 0!==h)return this.#e.build(this,e).setData(h,{...d,manual:!0})}setQueriesData(a,b,c){return e.notifyManager.batch(()=>this.#e.findAll(a).map(({queryKey:a})=>[a,this.setQueryData(a,b,c)]))}getQueryState(a){let b=this.defaultQueryOptions({queryKey:a});return this.#e.get(b.queryHash)?.state}removeQueries(a){let b=this.#e;e.notifyManager.batch(()=>{b.findAll(a).forEach(a=>{b.remove(a)})})}resetQueries(a,b){let c=this.#e;return e.notifyManager.batch(()=>(c.findAll(a).forEach(a=>{a.reset()}),this.refetchQueries({type:"active",...a},b)))}cancelQueries(a,b={}){let d={revert:!0,...b};return Promise.all(e.notifyManager.batch(()=>this.#e.findAll(a).map(a=>a.cancel(d)))).then(c.noop).catch(c.noop)}invalidateQueries(a,b={}){return e.notifyManager.batch(()=>(this.#e.findAll(a).forEach(a=>{a.invalidate()}),a?.refetchType==="none")?Promise.resolve():this.refetchQueries({...a,type:a?.refetchType??a?.type??"active"},b))}refetchQueries(a,b={}){let d={...b,cancelRefetch:b.cancelRefetch??!0};return Promise.all(e.notifyManager.batch(()=>this.#e.findAll(a).filter(a=>!a.isDisabled()&&!a.isStatic()).map(a=>{let b=a.fetch(void 0,d);return d.throwOnError||(b=b.catch(c.noop)),"paused"===a.state.fetchStatus?Promise.resolve():b}))).then(c.noop)}fetchQuery(a){let b=this.defaultQueryOptions(a);void 0===b.retry&&(b.retry=!1);let d=this.#e.build(this,b);return d.isStaleByTime((0,c.resolveStaleTime)(b.staleTime,d))?d.fetch(b):Promise.resolve(d.state.data)}prefetchQuery(a){return this.fetchQuery(a).then(c.noop).catch(c.noop)}fetchInfiniteQuery(a){return a.behavior=n(a.pages),this.fetchQuery(a)}prefetchInfiniteQuery(a){return this.fetchInfiniteQuery(a).then(c.noop).catch(c.noop)}ensureInfiniteQueryData(a){return a.behavior=n(a.pages),this.ensureQueryData(a)}resumePausedMutations(){return m.onlineManager.isOnline()?this.#f.resumePausedMutations():Promise.resolve()}getQueryCache(){return this.#e}getMutationCache(){return this.#f}getDefaultOptions(){return this.#g}setDefaultOptions(a){this.#g=a}setQueryDefaults(a,b){this.#h.set((0,c.hashKey)(a),{queryKey:a,defaultOptions:b})}getQueryDefaults(a){let b=[...this.#h.values()],d={};return b.forEach(b=>{(0,c.partialMatchKey)(a,b.queryKey)&&Object.assign(d,b.defaultOptions)}),d}setMutationDefaults(a,b){this.#i.set((0,c.hashKey)(a),{mutationKey:a,defaultOptions:b})}getMutationDefaults(a){let b=[...this.#i.values()],d={};return b.forEach(b=>{(0,c.partialMatchKey)(a,b.mutationKey)&&Object.assign(d,b.defaultOptions)}),d}defaultQueryOptions(a){if(a._defaulted)return a;let b={...this.#g.queries,...this.getQueryDefaults(a.queryKey),...a,_defaulted:!0};return b.queryHash||(b.queryHash=(0,c.hashQueryKeyByOptions)(b.queryKey,b)),void 0===b.refetchOnReconnect&&(b.refetchOnReconnect="always"!==b.networkMode),void 0===b.throwOnError&&(b.throwOnError=!!b.suspense),!b.networkMode&&b.persister&&(b.networkMode="offlineFirst"),b.queryFn===c.skipToken&&(b.enabled=!1),b}defaultMutationOptions(a){return a?._defaulted?a:{...this.#g.mutations,...a?.mutationKey&&this.getMutationDefaults(a.mutationKey),...a,_defaulted:!0}}clear(){this.#e.clear(),this.#f.clear()}},q=a.i(14220),r=a.i(98419);function s({children:a}){let[c]=(0,r.useState)(()=>new p({defaultOptions:{queries:{staleTime:5e3,refetchOnWindowFocus:!1}}}));return(0,b.jsx)(q.QueryClientProvider,{client:c,children:a})}a.s(["Providers",()=>s],17878)}];
-
-//# sourceMappingURL=%5Broot-of-the-server%5D__521be65c._.js.map