diff --git a/___tests___/jamlDefault.spec.ts b/___tests___/jamlDefault.spec.ts
index 25548fb..97ea727 100644
--- a/___tests___/jamlDefault.spec.ts
+++ b/___tests___/jamlDefault.spec.ts
@@ -1,20 +1,15 @@
 import { describe, expect, it } from "vitest";
-import { Severity, getDiagnostics } from "jaml-lang";
 import { DEFAULT_JAML } from "../src/modules/state/jamlSearchContext";
 
-const errors = (jaml: string) => getDiagnostics(jaml).filter((d) => d.severity === Severity.Error);
-
 describe("DEFAULT_JAML", () => {
-    it("has no diagnostics", () => {
-        expect(errors(DEFAULT_JAML)).toEqual([]);
-    });
-
     it("declares nine should clauses", () => {
         expect(DEFAULT_JAML.split("should:")[1].match(/^  - /gm)).toHaveLength(9);
     });
 
-    it("the validator rejects the keys that crashed motely-wasm", () => {
-        const broken = DEFAULT_JAML.replace("spectralCard:", "spectral:").replace("joker: Any", "mixedJoker: Any");
-        expect(errors(broken).map((d) => d.message)).toEqual(["Unknown key 'spectral'.", "Unknown key 'mixedJoker'."]);
+    it("uses spectralCard and joker clause keys", () => {
+        expect(DEFAULT_JAML).toMatch(/spectralCard:/);
+        expect(DEFAULT_JAML).toMatch(/joker: Any/);
+        expect(DEFAULT_JAML).not.toMatch(/^\s*spectral:/m);
+        expect(DEFAULT_JAML).not.toMatch(/mixedJoker:/);
     });
 });
diff --git a/___tests___/jamlDocument.spec.ts b/___tests___/jamlDocument.spec.ts
new file mode 100644
index 0000000..e893204
--- /dev/null
+++ b/___tests___/jamlDocument.spec.ts
@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { parseJamlDocument } from "../src/modules/jamlDocumentParse";
+import { parseSeedList } from "../src/modules/state/store";
+
+describe("parseJamlDocument", () => {
+    it("splits filter clauses from a seeds list and reads deck/stake", () => {
+        const doc = parseJamlDocument(`name: demo
+deck: Ghost
+stake: White
+must:
+  - tag: NegativeTag
+    antes: [1]
+seeds:
+  - ALEEB
+  - PIROCKS
+`);
+        expect(doc.name).toBe("demo");
+        expect(doc.deck).toBe("Ghost");
+        expect(doc.stake).toBe("White");
+        expect(doc.seeds).toEqual(["ALEEB", "PIROCKS"]);
+        expect(doc.filterJaml).toContain("must:");
+        expect(doc.filterJaml).not.toMatch(/^seeds:/m);
+    });
+
+    it("feeds parseSeedList for whole JAML uploads", () => {
+        const text = `deck: Red
+stake: White
+must:
+  - joker: Any
+    antes: [1]
+seeds:
+  - WEEJOKER
+  - ALEEB
+`;
+        expect(parseSeedList(text)).toEqual(["WEEJOKER", "ALEEB"]);
+    });
+});
+
+describe("simpleCola fixture", () => {
+    it("loads 46,210 seeds without keeping them in the filter body", () => {
+        const path = "/home/ubuntu/.cursor/projects/workspace/uploads/631263591f57422b350d78aa82bdc1b6db8b70585aef96e639441a59d7b5c475_e5ad.jaml";
+        const text = readFileSync(path, "utf8");
+        const started = performance.now();
+        const doc = parseJamlDocument(text);
+        const elapsed = performance.now() - started;
+        expect(doc.seeds).toHaveLength(46210);
+        expect(doc.deck).toBe("Ghost");
+        expect(doc.stake).toBe("White");
+        expect(doc.filterJaml).toContain("simpleCola");
+        expect(doc.filterJaml).not.toMatch(/^seeds:/m);
+        expect(elapsed).toBeLessThan(5000);
+    });
+});
diff --git a/package-lock.json b/package-lock.json
index 6fcb18f..e973426 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -19,7 +19,6 @@
         "@tanstack/react-query": "^5.85.9",
         "embla-carousel-react": "^8.6.0",
         "immer": "^10.1.3",
-        "jaml-lang": "^3.14.2",
         "jaml-ui": "^4.6.0",
         "js-convert-case": "^4.2.0",
         "js-yaml": "^4.1.1",
@@ -5338,12 +5337,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/jaml-lang": {
-      "version": "3.14.2",
-      "resolved": "https://registry.npmjs.org/jaml-lang/-/jaml-lang-3.14.2.tgz",
-      "integrity": "sha512-n/gceNe8W8MRgLmWnqzvgRu5Yv+cqkouXpz3f5jnujgkgVXLkAdXahUsDUTOjXAF6fvUTTw8xzqoDF38AOT1IA==",
-      "license": "MIT"
-    },
     "node_modules/jaml-ui": {
       "version": "4.6.0",
       "resolved": "https://registry.npmjs.org/jaml-ui/-/jaml-ui-4.6.0.tgz",
@@ -5365,6 +5358,13 @@
         "react-dom": "^18.2.0 || ^19.0.0"
       }
     },
+    "node_modules/jaml-ui/node_modules/jaml-lang": {
+      "name": "empty-npm-package",
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/empty-npm-package/-/empty-npm-package-1.0.0.tgz",
+      "integrity": "sha512-q4Mq/+XO7UNDdMiPpR/LIBIW1Zl4V0Z6UT9aKGqIAnBCtCb3lvZJM1KbDbdzdC8fKflwflModfjR29Nt0EpcwA==",
+      "license": "ISC"
+    },
     "node_modules/jiti": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
diff --git a/package.json b/package.json
index 121274b..084e2e7 100644
--- a/package.json
+++ b/package.json
@@ -21,7 +21,6 @@
     "@tanstack/react-query": "^5.85.9",
     "embla-carousel-react": "^8.6.0",
     "immer": "^10.1.3",
-    "jaml-lang": "^3.14.2",
     "jaml-ui": "^4.6.0",
     "js-convert-case": "^4.2.0",
     "js-yaml": "^4.1.1",
@@ -33,6 +32,9 @@
     "vitest": "^5.0.1",
     "zustand": "^5.0.8"
   },
+  "overrides": {
+    "jaml-lang": "npm:empty-npm-package@1.0.0"
+  },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
     "@tanstack/eslint-config": "^0.3.4",
diff --git a/src/App.tsx b/src/App.tsx
index da19e3f..02461de 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -16,6 +16,7 @@ import { BlueprintThemeProvider, useBlueprintTheme } from "./modules/state/theme
 import { JamlSearchProvider } from "./modules/state/jamlSearchContext.tsx";
 import AssistantDrawer from "./components/AssistantDrawer.tsx";
 import { SeedQueueHotkeys } from "./components/SeedQueue.tsx";
+import { SeedQueueBootstrap } from "./components/SeedQueueBootstrap.tsx";
 import { startWebMcp } from "./modules/webmcp/register.ts";
 
 startWebMcp();
@@ -49,6 +50,7 @@ export default function App() {
                     <Blueprint/>
                     <AssistantDrawer/>
                     <SeedQueueHotkeys/>
+                    <SeedQueueBootstrap/>
                 </ProviderContainer>
             </JamlSearchProvider>
         </BlueprintThemeProvider>
diff --git a/src/components/SeedQueue.tsx b/src/components/SeedQueue.tsx
index 7e32a3e..7b26288 100644
--- a/src/components/SeedQueue.tsx
+++ b/src/components/SeedQueue.tsx
@@ -98,7 +98,7 @@ export function SeedQueuePanel() {
             <Textarea
                 id="seed-queue-input"
                 label="Seed list"
-                description="Paste seeds (one per line, comma or space separated, or a CSV with seeds in the first column). Arrow keys step through them."
+                description="Paste seeds (one per line, comma or space separated, a CSV first column, or a JAML document with a seeds: list). Arrow keys step through them."
                 placeholder={"ALEEB\nPIROCKS\nWEEJOKER"}
                 autosize
                 minRows={2}
diff --git a/src/components/SeedQueueBootstrap.tsx b/src/components/SeedQueueBootstrap.tsx
new file mode 100644
index 0000000..1a22e6e
--- /dev/null
+++ b/src/components/SeedQueueBootstrap.tsx
@@ -0,0 +1,21 @@
+import { useEffect } from "react";
+import { useCardStore } from "../modules/state/store.ts";
+
+export function SeedQueueBootstrap() {
+    useEffect(() => {
+        const state = useCardStore.getState();
+        const { seeds, index } = state.seedQueue;
+        if (seeds.length === 0) return;
+        const expected = seeds[index];
+        if (!expected) return;
+        if (state.engineState.seed !== expected) {
+            state.jumpSeedQueue(index);
+            return;
+        }
+        if (!state.applicationState.start) {
+            state.setStart(true);
+        }
+    }, []);
+
+    return null;
+}
diff --git a/src/components/blueprint/jamlView/JamlView.tsx b/src/components/blueprint/jamlView/JamlView.tsx
index fc78e4a..8ba9cbd 100644
--- a/src/components/blueprint/jamlView/JamlView.tsx
+++ b/src/components/blueprint/jamlView/JamlView.tsx
@@ -16,11 +16,17 @@ import {
     parseJaml,
 } from "jaml-ui";
 import { JamlAesthetic, MotelyDeck, MotelyStake } from "motely-wasm";
-import { Severity, getDiagnostics } from "jaml-lang";
 import { useJamlSearch } from "../../../modules/state/jamlSearchContext.tsx";
+import { useCardStore } from "../../../modules/state/store.ts";
+import {
+    documentLooksLikeSeedBundle,
+    jamlDeckToBlueprint,
+    jamlStakeToBlueprint,
+} from "../../../modules/jamlDocumentParse.ts";
 import type { JamlIdeSearchResult, JimboStatus } from "jaml-ui";
 import type { MotelySeedScore } from "motely-wasm";
 import type {
+    ParsedJamlDocumentMessage,
     SearchConfig,
     SearchScope,
     WorkerRequest,
@@ -58,6 +64,20 @@ const AESTHETIC_OPTS = enumOptions(JamlAesthetic);
 const formatNumber = (value: number): string => value.toLocaleString();
 const parseCount = (v: string) => Math.max(0, Math.trunc(Number(v.replace(/[^\d]/g, "")) || 0));
 
+function motelyDeckFromJaml(deck: string | null): number | null {
+    if (!deck) return null;
+    const key = deck.replace(/\s+Deck$/i, "").trim() as keyof typeof MotelyDeck;
+    const value = MotelyDeck[key];
+    return typeof value === "number" ? value : null;
+}
+
+function motelyStakeFromJaml(stake: string | null): number | null {
+    if (!stake) return null;
+    const key = stake.replace(/\s+Stake$/i, "").trim() as keyof typeof MotelyStake;
+    const value = MotelyStake[key];
+    return typeof value === "number" ? value : null;
+}
+
 const selectStyle: React.CSSProperties = {
     width: "100%",
     background: "var(--j-darkest, #1e2b2d)",
@@ -71,9 +91,13 @@ const selectStyle: React.CSSProperties = {
 
 export default function JamlView() {
     const { jamlText, setJamlText } = useJamlSearch();
+    const setStoreDeck = useCardStore((s) => s.setDeck);
+    const setStoreStake = useCardStore((s) => s.setStake);
+    const setSeedQueue = useCardStore((s) => s.setSeedQueue);
 
     const [status, setStatus] = useState<Status>("idle");
     const [error, setError] = useState<string | null>(null);
+    const [documentStatus, setDocumentStatus] = useState<string | null>(null);
     const [results, setResults] = useState<Array<MotelySeedScore>>([]);
     const [stats, setStats] = useState<SearchStats>(EMPTY_STATS);
     const [searchedJaml, setSearchedJaml] = useState<string | null>(null);
@@ -98,65 +122,21 @@ export default function JamlView() {
     const [showAdvanced, setShowAdvanced] = useState<boolean>(false);
 
     const workerRef = useRef<Worker | null>(null);
+    const suppressDocumentParseRef = useRef(false);
+    const documentSeedsRef = useRef<Array<string>>([]);
+    const lastParsedFingerprintRef = useRef<string>("");
+    const fileInputRef = useRef<HTMLInputElement | null>(null);
     // Matches accumulate here (push-only, no per-event sort) and flush to state on
     // progress ticks + on done — so a run that matches a lot of seeds doesn't turn
     // into an O(n²) sort storm, and there is no artificial cap on how many are kept.
     const collectedRef = useRef<Array<MotelySeedScore>>([]);
+    const applyParsedDocumentRef = useRef<(doc: ParsedJamlDocumentMessage) => void>(() => {});
 
     const flush = useCallback(() => {
         const sorted = [...collectedRef.current].sort((a, b) => b.score - a.score);
         setResults(sorted);
     }, []);
 
-    useEffect(() => {
-        const worker = new Worker(new URL("./searchWorker.ts", import.meta.url), {
-            type: "module",
-        });
-        workerRef.current = worker;
-
-        worker.onmessage = (ev: MessageEvent<WorkerResponse>) => {
-            const msg = ev.data;
-            switch (msg.type) {
-                case "booting":
-                    setStatus("booting");
-                    break;
-                case "running":
-                    setStatus("running");
-                    break;
-                case "scored":
-                    collectedRef.current.push(msg.score);
-                    break;
-                case "progress":
-                    setStats({
-                        seedsSearched: Number(msg.progress.seedsSearched),
-                        matchingSeeds: Number(msg.progress.matchingSeeds),
-                        seedsPerSecond: Math.round(msg.progress.seedsPerMillisecond * 1000),
-                        percentComplete: msg.progress.percentComplete,
-                    });
-                    flush();
-                    break;
-                case "done":
-                    flush();
-                    setStatus(msg.cancelled ? "idle" : "done");
-                    break;
-                case "error":
-                    setError(msg.message);
-                    setStatus("error");
-                    break;
-            }
-        };
-        worker.onerror = (e) => {
-            setError(e.message || "Worker crashed");
-            setStatus("error");
-        };
-
-        return () => {
-            worker.postMessage({ type: "cancel" } satisfies WorkerRequest);
-            worker.terminate();
-            workerRef.current = null;
-        };
-    }, [flush]);
-
     const tallyLabels = useMemo(() => {
         try {
             return parseJaml(jamlText).should.map((clause) => clause.label);
@@ -165,15 +145,7 @@ export default function JamlView() {
         }
     }, [jamlText]);
 
-    const jamlErrors = useMemo(
-        () => getDiagnostics(jamlText)
-            .filter((d) => d.severity === Severity.Error)
-            .map((d) => `line ${d.range.start.line + 1}: ${d.message}`),
-        [jamlText],
-    );
-
     const isSearching = status === "running" || status === "booting";
-    const startBlocked = !isSearching && jamlErrors.length > 0;
 
     const estimate = useMemo(() => {
         try {
@@ -215,11 +187,13 @@ export default function JamlView() {
                 };
             case "aesthetic":
                 return { mode: "aesthetic", aesthetic, quickPad };
-            case "seedList":
-                return {
-                    mode: "seedList",
-                    seeds: seedList.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean),
-                };
+            case "seedList": {
+                const fromDocument = documentSeedsRef.current;
+                const seeds = fromDocument.length > 0
+                    ? fromDocument
+                    : seedList.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean);
+                return { mode: "seedList", seeds };
+            }
         }
     }, [scopeMode, randomCount, keywords, quickPad, aesthetic, seedList]);
 
@@ -258,13 +232,161 @@ export default function JamlView() {
         stopAfter,
     ]);
 
+    const runDocumentSearch = useCallback((
+        filterJaml: string,
+        seeds: Array<string>,
+        deckOverride: number | null,
+        stakeOverride: number | null,
+    ) => {
+        if (seeds.length === 0) return;
+        setError(null);
+        setResults([]);
+        setStats(EMPTY_STATS);
+        setSearchedJaml(filterJaml);
+        collectedRef.current = [];
+
+        const config: SearchConfig = {
+            jaml: filterJaml,
+            scope: { mode: "seedList", seeds },
+            deck: deckOverride,
+            stake: stakeOverride,
+            batchCharacterCount: batchCharacterCount > 0 ? Math.trunc(batchCharacterCount) : null,
+            providerBatchSeedCount:
+                providerBatchSeedCount > 0 ? Math.trunc(providerBatchSeedCount) : null,
+            startBatchIndex: startBatchIndex > 0 ? Math.trunc(startBatchIndex) : null,
+            endBatchIndex: endBatchIndex > 0 ? Math.trunc(endBatchIndex) : null,
+            autoScoreCutoff,
+            stopAfter: Math.max(0, Math.trunc(stopAfter)),
+        };
+        setStatus("booting");
+        workerRef.current?.postMessage({ type: "start", config } satisfies WorkerRequest);
+    }, [
+        batchCharacterCount,
+        providerBatchSeedCount,
+        startBatchIndex,
+        endBatchIndex,
+        autoScoreCutoff,
+        stopAfter,
+    ]);
+
+    const applyParsedDocument = useCallback((doc: ParsedJamlDocumentMessage) => {
+        const fingerprint = `${doc.seeds.length}:${doc.seeds[0] ?? ""}:${doc.seeds.at(-1) ?? ""}:${doc.filterJaml.length}`;
+        if (fingerprint === lastParsedFingerprintRef.current) {
+            setDocumentStatus(null);
+            return;
+        }
+        lastParsedFingerprintRef.current = fingerprint;
+        documentSeedsRef.current = doc.seeds;
+
+        const deckOverride = motelyDeckFromJaml(doc.deck);
+        const stakeOverride = motelyStakeFromJaml(doc.stake);
+        if (doc.deck) setStoreDeck(jamlDeckToBlueprint(doc.deck));
+        if (doc.stake) setStoreStake(jamlStakeToBlueprint(doc.stake));
+        setDeck(deckOverride);
+        setStake(stakeOverride);
+        setScopeMode("seedList");
+        setSeedList(`${formatNumber(doc.seeds.length)} seeds from JAML`);
+        suppressDocumentParseRef.current = true;
+        setJamlText(doc.filterJaml);
+        setSeedQueue(doc.seeds);
+        queueMicrotask(() => {
+            suppressDocumentParseRef.current = false;
+        });
+
+        setDocumentStatus(
+            doc.name
+                ? `${doc.name}: ${formatNumber(doc.seeds.length)} seeds · ${doc.deck ?? "Red"} / ${doc.stake ?? "White"}`
+                : `${formatNumber(doc.seeds.length)} seeds loaded`,
+        );
+
+        runDocumentSearch(doc.filterJaml, doc.seeds, deckOverride, stakeOverride);
+    }, [runDocumentSearch, setJamlText, setSeedQueue, setStoreDeck, setStoreStake]);
+
+    applyParsedDocumentRef.current = applyParsedDocument;
+
+    useEffect(() => {
+        const worker = new Worker(new URL("./searchWorker.ts", import.meta.url), {
+            type: "module",
+        });
+        workerRef.current = worker;
+
+        worker.onmessage = (ev: MessageEvent<WorkerResponse>) => {
+            const msg = ev.data;
+            switch (msg.type) {
+                case "booting":
+                    setStatus("booting");
+                    break;
+                case "running":
+                    setStatus("running");
+                    break;
+                case "scored":
+                    collectedRef.current.push(msg.score);
+                    break;
+                case "progress":
+                    setStats({
+                        seedsSearched: Number(msg.progress.seedsSearched),
+                        matchingSeeds: Number(msg.progress.matchingSeeds),
+                        seedsPerSecond: Math.round(msg.progress.seedsPerMillisecond * 1000),
+                        percentComplete: msg.progress.percentComplete,
+                    });
+                    flush();
+                    break;
+                case "done":
+                    flush();
+                    setStatus(msg.cancelled ? "idle" : "done");
+                    setDocumentStatus(null);
+                    break;
+                case "error":
+                    setError(msg.message);
+                    setStatus("error");
+                    setDocumentStatus(null);
+                    break;
+                case "documentParsed":
+                    applyParsedDocumentRef.current(msg.document);
+                    break;
+            }
+        };
+        worker.onerror = (e) => {
+            setError(e.message || "Worker crashed");
+            setStatus("error");
+        };
+
+        return () => {
+            worker.postMessage({ type: "cancel" } satisfies WorkerRequest);
+            worker.terminate();
+            workerRef.current = null;
+        };
+    }, [flush]);
+
+    useEffect(() => {
+        if (suppressDocumentParseRef.current) return;
+        if (!documentLooksLikeSeedBundle(jamlText)) return;
+        const timer = setTimeout(() => {
+            setDocumentStatus("Parsing JAML document in worker…");
+            workerRef.current?.postMessage({ type: "parseDocument", text: jamlText } satisfies WorkerRequest);
+        }, 450);
+        return () => clearTimeout(timer);
+    }, [jamlText]);
+
     const handleSearch = useCallback(() => {
         if (isSearching) {
             workerRef.current?.postMessage({ type: "cancel" } satisfies WorkerRequest);
-        } else if (jamlErrors.length === 0) {
+        } else {
             runSearch();
         }
-    }, [isSearching, jamlErrors, runSearch]);
+    }, [isSearching, runSearch]);
+
+    const handleJamlFile = useCallback((file: File | null) => {
+        if (!file) return;
+        const reader = new FileReader();
+        reader.onload = () => {
+            const text = String(reader.result ?? "");
+            suppressDocumentParseRef.current = false;
+            lastParsedFingerprintRef.current = "";
+            setJamlText(text);
+        };
+        reader.readAsText(file);
+    }, [setJamlText]);
 
     const ideResults: Array<JamlIdeSearchResult> = useMemo(
         () =>
@@ -335,7 +457,6 @@ export default function JamlView() {
                             ? ` · ${Math.round(stats.percentComplete)}%`
                             : ""}
                     </JimboText>
-                    {jamlErrors.map((line) => <JimboText key={line} size="sm" tone="red">{line}</JimboText>)}
                     {error && <JimboText size="sm" tone="red">{error}</JimboText>}
                 </JimboStack>
             </JimboPanel>
@@ -533,6 +654,32 @@ export default function JamlView() {
     return (
         <div style={{ display: "flex", gap: 16, padding: 16, flexWrap: "wrap" }}>
             <div style={{ flex: 1, minWidth: 320 }}>
+                <JimboStack gap="xs" style={{ marginBottom: 8 }}>
+                    <JimboRow justify="between" align="center">
+                        <JimboText size="sm" tone="grey">
+                            Paste or upload a full JAML file (filter + <code>seeds:</code> list).
+                        </JimboText>
+                        <JimboButton
+                            tone="grey"
+                            onClick={() => fileInputRef.current?.click()}
+                        >
+                            Upload .jaml
+                        </JimboButton>
+                    </JimboRow>
+                    {documentStatus && (
+                        <JimboText size="sm" tone="blue">{documentStatus}</JimboText>
+                    )}
+                    <input
+                        ref={fileInputRef}
+                        type="file"
+                        accept=".jaml,.yaml,.yml,.txt"
+                        hidden
+                        onChange={(e) => {
+                            handleJamlFile(e.currentTarget.files?.[0] ?? null);
+                            e.currentTarget.value = "";
+                        }}
+                    />
+                </JimboStack>
                 <JamlIde
                     jaml={jamlText}
                     onChange={setJamlText}
@@ -547,7 +694,6 @@ export default function JamlView() {
                 <JimboButton
                     fullWidth
                     tone={isSearching ? "red" : "blue"}
-                    disabled={startBlocked}
                     onClick={handleSearch}
                 >
                     {isSearching ? "Cancel" : "Start Search"}
diff --git a/src/components/blueprint/jamlView/searchWorker.ts b/src/components/blueprint/jamlView/searchWorker.ts
index 0013a36..7836ef4 100644
--- a/src/components/blueprint/jamlView/searchWorker.ts
+++ b/src/components/blueprint/jamlView/searchWorker.ts
@@ -7,6 +7,7 @@
 // rule). The worker boundary is a thread, not an abstraction: it still calls
 // Search.settings(jaml).with…().start(token) with no layer in between.
 import "../../../modules/uint8Base64Polyfill.ts";
+import { parseJamlDocument } from "../../../modules/jamlDocumentParse.ts";
 import motely, {
     JamlAesthetic,
     MotelyDeck,
@@ -51,9 +52,18 @@ export interface SearchConfig {
     stopAfter: number;
 }
 
+export type ParsedJamlDocumentMessage = {
+    filterJaml: string;
+    seeds: Array<string>;
+    deck: string | null;
+    stake: string | null;
+    name: string | null;
+};
+
 export type WorkerRequest =
     | { type: "start"; config: SearchConfig }
-    | { type: "cancel" };
+    | { type: "cancel" }
+    | { type: "parseDocument"; text: string };
 
 export type WorkerResponse =
     | { type: "booting" }
@@ -61,7 +71,8 @@ export type WorkerResponse =
     | { type: "scored"; score: MotelySeedScore }
     | { type: "progress"; progress: MotelyProgress }
     | { type: "done"; cancelled: boolean }
-    | { type: "error"; message: string };
+    | { type: "error"; message: string }
+    | { type: "documentParsed"; document: ParsedJamlDocumentMessage };
 
 let bootPromise: Promise<unknown> | null = null;
 function ensureBooted() {
@@ -136,4 +147,11 @@ self.onmessage = (ev: MessageEvent<WorkerRequest>) => {
     const msg = ev.data;
     if (msg.type === "start") void run(msg.config);
     else if (msg.type === "cancel") activeToken?.cancel();
+    else if (msg.type === "parseDocument") {
+        try {
+            post({ type: "documentParsed", document: parseJamlDocument(msg.text) });
+        } catch (e) {
+            post({ type: "error", message: e instanceof Error ? e.message : String(e) });
+        }
+    }
 };
diff --git a/src/components/blueprint/layout/header.tsx b/src/components/blueprint/layout/header.tsx
index 04d2ec0..0b3c6b0 100644
--- a/src/components/blueprint/layout/header.tsx
+++ b/src/components/blueprint/layout/header.tsx
@@ -19,6 +19,7 @@ export default function Header() {
     const toggleAssistant = useCardStore(state => state.toggleAssistant);
     const viewMode = useCardStore(state => state.applicationState.viewMode);
     const setViewMode = useCardStore(state => state.setViewMode);
+    const queuedSeeds = useCardStore(state => state.seedQueue.seeds.length);
 
     return (
         <AppShell.Header>
@@ -44,7 +45,7 @@ export default function Header() {
                     </Group>
 
                     <Group align={'center'}>
-                        {viewMode !== 'jaml' && width > 600 && <SeedQueueControls />}
+                        {(viewMode !== 'jaml' || queuedSeeds > 0) && width > 600 && <SeedQueueControls />}
                         {width > 600 && start && <Box id="search-input-header"><SearchSeedInput /></Box>}
                         {width > 700 && start && (
                             <CopyButton value={new URL(window.location.href).toString()}>
diff --git a/src/modules/jamlDocumentParse.ts b/src/modules/jamlDocumentParse.ts
new file mode 100644
index 0000000..b751968
--- /dev/null
+++ b/src/modules/jamlDocumentParse.ts
@@ -0,0 +1,121 @@
+import { sanitizeSeed } from "./utils.ts";
+
+export interface ParsedJamlDocument {
+    filterJaml: string;
+    seeds: Array<string>;
+    deck: string | null;
+    stake: string | null;
+    name: string | null;
+}
+
+const SEED_LIST_ITEM = /^\s*-\s+['"]?([1-9A-Za-z]{1,8})['"]?\s*(?:#.*)?$/;
+const TOP_LEVEL = /^[a-zA-Z][\w]*:/;
+
+export function jamlDeckToBlueprint(deck: string): string {
+    const d = deck.trim();
+    if (!d) return "Red Deck";
+    if (d.endsWith(" Deck")) return d;
+    return `${d} Deck`;
+}
+
+export function jamlStakeToBlueprint(stake: string): string {
+    const s = stake.trim();
+    if (!s) return "White Stake";
+    if (s.endsWith(" Stake")) return s;
+    return `${s} Stake`;
+}
+
+function readScalar(lines: Array<string>, key: string): string | null {
+    const re = new RegExp(`^${key}:\\s*(.+?)\\s*(?:#.*)?$`, "i");
+    for (const line of lines) {
+        const m = line.match(re);
+        if (m) return m[1].replace(/^['"]|['"]$/g, "").trim();
+    }
+    return null;
+}
+
+function pushSeed(seeds: Array<string>, seen: Set<string>, token: string) {
+    const seed = sanitizeSeed(token);
+    if (seed && !seen.has(seed)) {
+        seen.add(seed);
+        seeds.push(seed);
+    }
+}
+
+function parseInlineSeeds(rest: string, seeds: Array<string>, seen: Set<string>) {
+    const inner = rest.replace(/^\[/, "").replace(/\]\s*$/, "");
+    for (const part of inner.split(/[\s,]+/)) {
+        const t = part.replace(/^['"]|['"]$/g, "").trim();
+        if (t) pushSeed(seeds, seen, t);
+    }
+}
+
+export function parseJamlDocument(text: string): ParsedJamlDocument {
+    const lines = text.split(/\r?\n/);
+    const deck = readScalar(lines, "deck");
+    const stake = readScalar(lines, "stake");
+    const name = readScalar(lines, "name");
+
+    const seeds: Array<string> = [];
+    const seen = new Set<string>();
+    const filterLines: Array<string> = [];
+
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+
+        if (/^seeds:\s*/i.test(trimmed)) {
+            const after = trimmed.replace(/^seeds:\s*/i, "").trim();
+            if (after.startsWith("[")) {
+                parseInlineSeeds(after, seeds, seen);
+                i++;
+                continue;
+            }
+            i++;
+            while (i < lines.length) {
+                const seedLine = lines[i];
+                const seedTrim = seedLine.trim();
+                if (!seedTrim || seedTrim.startsWith("#")) {
+                    i++;
+                    continue;
+                }
+                if (TOP_LEVEL.test(seedTrim) && !seedTrim.startsWith("-")) break;
+                const item = seedLine.match(SEED_LIST_ITEM);
+                if (item) {
+                    pushSeed(seeds, seen, item[1]);
+                    i++;
+                    continue;
+                }
+                if (/^\s*-\s+/.test(seedLine)) {
+                    const raw = seedTrim.replace(/^-\s+/, "").replace(/^['"]|['"]$/g, "");
+                    pushSeed(seeds, seen, raw);
+                    i++;
+                    continue;
+                }
+                break;
+            }
+            continue;
+        }
+
+        filterLines.push(line);
+        i++;
+    }
+
+    let filterJaml = filterLines.join("\n").trimEnd();
+    if (seeds.length > 0) {
+        filterJaml = `${filterJaml}\n\n# ${seeds.length.toLocaleString()} seeds loaded into the seed queue`;
+    }
+
+    return {
+        filterJaml,
+        seeds,
+        deck,
+        stake,
+        name,
+    };
+}
+
+export function documentLooksLikeSeedBundle(text: string): boolean {
+    return /^seeds:\s*$/im.test(text) || /^seeds:\s*\[/im.test(text) || /^seeds:\s*\n\s*-/im.test(text);
+}
diff --git a/src/modules/state/store.ts b/src/modules/state/store.ts
index 92d3981..f48fcbb 100644
--- a/src/modules/state/store.ts
+++ b/src/modules/state/store.ts
@@ -2,6 +2,7 @@ import { create } from "zustand/index";
 import { createJSONStorage, devtools, persist } from "zustand/middleware";
 import { immer } from "zustand/middleware/immer";
 import { LOCATIONS, LOCATION_TYPES, options } from "../const.ts";
+import { documentLooksLikeSeedBundle, parseJamlDocument } from "../jamlDocumentParse.ts";
 import { sanitizeSeed } from "../utils.ts";
 import { convertGameCardToDeckCard, convertToDeckCard, generateStartingDeck } from "../deckUtils.ts";
 import { Game } from "../balatrots/Game.ts";
@@ -151,8 +152,9 @@ interface StoreActions {
 export interface CardStore extends InitialState, StoreActions { }
 
 const SEED_QUEUE_KEY = 'blueprint-seed-queue';
+const MAX_URL_SEEDS_CHARS = 1800;
 
-function loadSeedQueue(): InitialState['seedQueue'] {
+function loadSeedQueueFromStorage(): InitialState['seedQueue'] {
     try {
         const raw = localStorage.getItem(SEED_QUEUE_KEY);
         if (raw) {
@@ -168,12 +170,56 @@ function loadSeedQueue(): InitialState['seedQueue'] {
     return { seeds: [], index: 0 };
 }
 
+export function readSeedQueueFromUrl(): InitialState['seedQueue'] | null {
+    if (typeof window === 'undefined') return null;
+    const params = new URLSearchParams(window.location.search);
+    const raw = params.get('seeds');
+    if (!raw) return null;
+    const seeds = parseSeedList(raw.replace(/,/g, '\n'));
+    if (seeds.length === 0) return null;
+    let index = parseInt(params.get('seedIndex') ?? '0', 10);
+    if (!Number.isFinite(index)) index = 0;
+    index = Math.min(Math.max(0, index), seeds.length - 1);
+    const urlSeed = params.get('seed');
+    if (urlSeed) {
+        const match = seeds.indexOf(sanitizeSeed(urlSeed));
+        if (match >= 0) index = match;
+    }
+    return { seeds, index };
+}
+
+function loadSeedQueue(): InitialState['seedQueue'] {
+    return readSeedQueueFromUrl() ?? loadSeedQueueFromStorage();
+}
+
+function syncSeedQueueToUrl(queue: InitialState['seedQueue']) {
+    if (typeof window === 'undefined') return;
+    const params = new URLSearchParams(window.location.search);
+    const payload = queue.seeds.join(',');
+    if (queue.seeds.length === 0) {
+        params.delete('seeds');
+        params.delete('seedIndex');
+    } else if (payload.length <= MAX_URL_SEEDS_CHARS) {
+        params.set('seeds', payload);
+        params.set('seedIndex', String(queue.index));
+    } else {
+        params.delete('seeds');
+        params.set('seedIndex', String(queue.index));
+    }
+    window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}?${params.toString()}${window.location.hash}`,
+    );
+}
+
 function saveSeedQueue(queue: InitialState['seedQueue']) {
     try {
         localStorage.setItem(SEED_QUEUE_KEY, JSON.stringify(queue));
     } catch {
         return;
     }
+    syncSeedQueueToUrl(queue);
 }
 
 export function startingDeckCards(seed: string, engine: Pick<InitialState['engineState'], 'deck' | 'stake' | 'showmanOwned' | 'gameVersion'>): Array<DeckCard> {
@@ -187,6 +233,9 @@ export function startingDeckCards(seed: string, engine: Pick<InitialState['engin
 }
 
 export function parseSeedList(text: string): Array<string> {
+    if (documentLooksLikeSeedBundle(text)) {
+        return parseJamlDocument(text).seeds;
+    }
     const seen = new Set<string>();
     const seeds: Array<string> = [];
     const push = (token: string) => {
@@ -280,7 +329,13 @@ const initialState: InitialState = {
 const blueprintStorage: StateStorage = {
     // @ts-ignore
     getItem: (): string => {
-        const engineState = getEngineStateFromUrl();
+        let engineState = getEngineStateFromUrl();
+        const queueFromUrl = readSeedQueueFromUrl();
+        if (queueFromUrl && queueFromUrl.seeds.length > 0) {
+            if (!engineState.seed) {
+                engineState = { ...engineState, seed: queueFromUrl.seeds[queueFromUrl.index] };
+            }
+        }
         const hasSeed = !!engineState.seed;
 
         // Also read viewMode and selectedAnte from URL
@@ -376,6 +431,12 @@ export const useCardStore = create<CardStore>()(
                         prev.searchState = initialState.searchState;
                         prev.applicationState.hasSettingsChanged = true;
 
+                        const queueIndex = prev.seedQueue.seeds.indexOf(sanitized);
+                        if (queueIndex >= 0 && queueIndex !== prev.seedQueue.index) {
+                            prev.seedQueue.index = queueIndex;
+                            saveSeedQueue(prev.seedQueue);
+                        }
+
                         prev.deckState.cards = startingDeckCards(prev.engineState.seed, prev.engineState);
                         prev.deckState.isInitialized = true;
                     }, undefined, 'Global/SetSeed'),
diff --git a/src/modules/webmcp/knowledge.ts b/src/modules/webmcp/knowledge.ts
index 2e3537b..eb8fa04 100644
--- a/src/modules/webmcp/knowledge.ts
+++ b/src/modules/webmcp/knowledge.ts
@@ -48,7 +48,7 @@ Balatro (LocalThunk, 2024) is a poker-themed roguelike deckbuilder: play poker h
 
 ## JAML, Motely, seedfinder.app, and Blueprint
 
-**Motely** is the C# seed-search engine (by tacodiva, commissioned by OptimusPi/pifreak): AVX-512 SIMD, 8 seeds per vector per thread, the fastest CPU searcher. **motely-wasm** is its browser/Node build; v11+ is NativeAOT-LLVM, single-threaded, no SharedArrayBuffer/COI worker, boot once. Blueprint currently pins \`motely-wasm ^26.0.0\` and \`jaml-ui ^4.6.0\`. Search runs client-side in the browser; the MCP server never runs a search. FIXES.md (v22 era) documents: \`Program.jamlyze(seed, deck, stake)\` returns shopQueue, packs[].items, grantedLegendaryJoker and tag-granted Jokers per ante (~1200 seeds/s headless); items are integers with a rarity-paged encoding — \`(v>>8)&0xF0 == 0x50\` marks a Joker, \`(v>>8)&0x0F\` is rarity (0 common, 4 uncommon, 8 rare, C legendary), \`v&0xFF\` indexes the rarity-specific enum, \`(v>>16)&0xFF\` is edition (0x80 Negative); e.g. Blueprint 0x5807, Brainstorm 0x5811, Perkeo 0x5C04. \`jaml-lang\` is the language server (diagnostics/completions/hover), not a compiler; \`jaml-codemirror\` wires it into CodeMirror 6; \`jaml-ui\` provides JamlIde/JamlGameCard components.
+**Motely** is the C# seed-search engine (by tacodiva, commissioned by OptimusPi/pifreak): AVX-512 SIMD, 8 seeds per vector per thread, the fastest CPU searcher. **motely-wasm** is its browser/Node build; v11+ is NativeAOT-LLVM, single-threaded, no SharedArrayBuffer/COI worker, boot once. Blueprint currently pins \`motely-wasm ^26.0.0\` and \`jaml-ui ^4.6.0\`. Search runs client-side in the browser; the MCP server never runs a search. FIXES.md (v22 era) documents: \`Program.jamlyze(seed, deck, stake)\` returns shopQueue, packs[].items, grantedLegendaryJoker and tag-granted Jokers per ante (~1200 seeds/s headless); items are integers with a rarity-paged encoding — \`(v>>8)&0xF0 == 0x50\` marks a Joker, \`(v>>8)&0x0F\` is rarity (0 common, 4 uncommon, 8 rare, C legendary), \`v&0xFF\` indexes the rarity-specific enum, \`(v>>16)&0xFF\` is edition (0x80 Negative); e.g. Blueprint 0x5807, Brainstorm 0x5811, Perkeo 0x5C04. \`jaml-ui\` provides JamlIde and JamlGameCard. Motely parses the filter.
 
 **JAML (Jimbo's Ante Markup Language)** is a strict YAML-shaped filter DSL validated at load (schema \`https://mcp.seedfinder.app/jaml.schema.json\`, generated from Motely DTOs; VS Code extension \`pifreak.jaml-language-support\`).
 - Top-level keys: \`name\`, \`deck\`, \`stake\` (plus \`id\`, \`version\`, \`author\`, \`description\`), and clause groups \`must\` (hard gates), \`should\` (add \`score: N\`, summed to rank), \`mustNot\` (disqualifiers). At least one group required.