brane 0.1.1 → 0.3.1

package/dist/test/search-fusion.test.js

@@ -0,0 +1,168 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { initMemorySchema, prepareFtsAnyQuery, prepareFtsQuery, searchHybrid, upsertChunks, } from "../memory/storage.js";
+// What this file pins is *ranking*, which had no test at all and so drifted
+// until an exact quotation from a real message came back at rank 1 less than
+// half the time. Measured on the operator's 43,876-chunk archive, the fusion
+// this suite describes took that from 48% to 95%.
+//
+// Those corpus percentages can't live in a unit test — they move with the
+// archive (the same probe read 52%, 47% and 37% across one afternoon as new
+// events were indexed). So each case below is instead the *smallest corpus
+// that reproduces one defect*, with vectors chosen by hand. A percentage tells
+// you something regressed; these tell you which thing.
+//
+// Vectors are synthetic for the same reason search-floor.test.ts uses them: a
+// real embedder won't give you the same similarity twice, and every case here
+// turns on the vector arm being deliberately *wrong* — that's the situation the
+// lexical arms exist to survive.
+const DIM = 384;
+/** A unit vector whose cosine similarity to {@link QUERY} is `target`. */
+function withSimilarity(target, axis = 1) {
+    const v = new Float32Array(DIM);
+    v[0] = target;
+    v[axis] = Math.sqrt(Math.max(0, 1 - target * target));
+    return v;
+}
+const QUERY = withSimilarity(1);
+function seed(rows) {
+    const db = createTestDb();
+    initMemorySchema(db);
+    db.prepare(`INSERT OR IGNORE INTO narratives (id, brane_id, agent_type, role, created_at, status)
+     VALUES ('claude-test', 'brane-test', 'claude', 'worker', 0, 'active')`).run();
+    upsertChunks(db, rows.map((r, i) => ({
+        id: `claude-test:${i + 1}`,
+        narrative_id: "claude-test",
+        seq: i + 1,
+        content: r.content,
+        time: i,
+        vector: withSimilarity(r.similarity, (i % (DIM - 1)) + 1),
+    })));
+    return db;
+}
+const contents = (db, query, limit = 10) => searchHybrid(db, QUERY, query, limit).map((r) => r.content);
+describe("search fusion", () => {
+    // The case that motivated all of this. On the real archive, this query's only
+    // all-terms match in 43,876 chunks came back 11th, behind ten one-line
+    // operator signals that each contained the single word "daemon" and happened
+    // to sit near the query in embedding space.
+    //
+    // Two compounding causes, both reproduced here: a flat +0.5 for *any* term
+    // appearing (so 1-of-8 scored like 8-of-8), and score-blending two arms whose
+    // numbers aren't on the same scale (so the vector arm won by construction).
+    it("ranks the one chunk containing the whole query above topical one-liners", () => {
+        const db = seed([
+            {
+                content: "The self-inflicted instance restarted the daemon four times today, " +
+                    "each time because a config write raced the supervisor's health check.",
+                similarity: 0.64, // *below* the noise: the vector arm is no help here
+            },
+            { content: "Daemon is restarted", similarity: 0.82 },
+            { content: "Restarting daemon now.", similarity: 0.79 },
+            { content: "Restart* daemon", similarity: 0.78 },
+            { content: "Now restart the daemon and test it yourself", similarity: 0.77 },
+            { content: "daemon restarted", similarity: 0.76 },
+        ]);
+        const top = contents(db, "self-inflicted instance restarted the daemon four times today")[0];
+        assert.match(top, /self-inflicted instance restarted/);
+    });
+    // Coverage has to *scale*, not merely exist. A row holding every query term
+    // must beat one holding a single term, however similar the latter looks.
+    it("scores partial keyword matches below complete ones", () => {
+        const db = seed([
+            { content: "one term only: embedding", similarity: 0.9 },
+            { content: "tokenizer embedding pooling normalization vectors", similarity: 0.5 },
+        ]);
+        assert.match(contents(db, "tokenizer embedding pooling normalization vectors")[0], /tokenizer embedding pooling/);
+    });
+    // The ANY arm's reason to exist. FTS5's implicit AND requires every term, so
+    // a natural-language question — which no single chunk ever contains in full —
+    // returned *zero* lexical candidates, silently disabling half of a "hybrid"
+    // search at precisely the moment it was asked a hard question.
+    it("finds the best partial match when no chunk contains every query term", () => {
+        const db = seed([
+            { content: "The intraOpNumThreads cap made embedding six times slower.", similarity: 0.6 },
+            { content: "Unrelated note about terminal cursor rendering.", similarity: 0.61 },
+            { content: "Another unrelated note about payload storage.", similarity: 0.62 },
+        ]);
+        const query = "which thread setting made embedding six times slower than before";
+        // Precondition, asserted rather than assumed: the strict arm really does
+        // come back empty here. If it ever stops doing so, this test is measuring
+        // something else and should be rewritten rather than silently passing.
+        const strict = db
+            .prepare("SELECT count(*) AS n FROM memory_fts WHERE memory_fts MATCH ?")
+            .get(prepareFtsQuery(query));
+        assert.equal(strict.n, 0);
+        assert.match(contents(db, query)[0], /intraOpNumThreads/);
+    });
+    // A quoted phrase is an instruction, not a preference — the one filter
+    // allowed to return nothing. The vector arm unions in rows independently, so
+    // without this it would rank rather than restrict.
+    it("treats a quoted phrase as a requirement", () => {
+        const db = seed([
+            { content: "the exact phrase we want lives here", similarity: 0.3 },
+            { content: "a much closer neighbour that lacks it", similarity: 0.99 },
+        ]);
+        const results = searchHybrid(db, QUERY, '"exact phrase we want"', 10);
+        assert.equal(results.length, 1);
+        assert.match(results[0].content, /exact phrase we want/);
+    });
+    // ...but only quoting may empty the page. A loosely-remembered query gets
+    // best-effort guesses, marked `weak`, rather than nothing.
+    it("never returns an empty page for an unquoted query", () => {
+        const db = seed([
+            { content: "something about terminals", similarity: 0.4 },
+            { content: "something about payloads", similarity: 0.39 },
+        ]);
+        const results = searchHybrid(db, QUERY, "zzqqxx blorptangle wibblefrotz", 10);
+        assert.ok(results.length > 0);
+        assert.ok(results.every((r) => r.match === "weak"));
+    });
+    // The length penalty used to sit in the same branch as the missing keyword
+    // boost, so a 15-character chunk holding one query word skipped the penalty
+    // *and* collected the bonus. It now applies to rows with no lexical evidence,
+    // which is the only place it was ever meant to.
+    it("discounts very short chunks that match nothing lexically", () => {
+        const db = seed([
+            { content: "ok", similarity: 0.88 },
+            {
+                content: "A full paragraph of genuinely relevant prose that does not repeat " +
+                    "the query's vocabulary but is long enough to be a real answer.",
+                similarity: 0.86,
+            },
+        ]);
+        assert.match(contents(db, "some unrelated wording entirely")[0], /full paragraph/);
+    });
+    // A single rare identifier is the query most at risk from adding an OR arm:
+    // it must not get diluted by loosely-related rows.
+    it("keeps a rare identifier's exact match at rank 1", () => {
+        const db = seed([
+            { content: "Set intraOpNumThreads to 8; it saturates there.", similarity: 0.5 },
+            { content: "thread pool sizing notes", similarity: 0.9 },
+            { content: "more about threads and pools", similarity: 0.89 },
+        ]);
+        assert.match(contents(db, "intraOpNumThreads")[0], /intraOpNumThreads/);
+    });
+});
+describe("prepareFtsAnyQuery", () => {
+    it("ORs content terms and drops stopwords", () => {
+        const q = prepareFtsAnyQuery("can we remove the unused code from the bundle");
+        assert.equal(q, '("remove"* OR "unused"* OR "code"* OR "bundle"*)');
+    });
+    it("keeps quoted phrases conjunctive alongside the OR group", () => {
+        const q = prepareFtsAnyQuery('"exact thing" alpha beta');
+        assert.equal(q, '"exact thing" ("alpha"* OR "beta"*)');
+    });
+    // One term ORed with nothing is just that term — the strict arm already runs
+    // it, and a duplicate query is pure cost.
+    it("declines a single-term query, leaving it to the strict arm", () => {
+        assert.equal(prepareFtsAnyQuery("intraOpNumThreads"), null);
+        assert.equal(prepareFtsAnyQuery("the of and"), null);
+    });
+    it("returns null for an empty query", () => {
+        assert.equal(prepareFtsAnyQuery(""), null);
+        assert.equal(prepareFtsAnyQuery("   "), null);
+    });
+});
+//# sourceMappingURL=search-fusion.test.js.map

package/dist/test/search.test.js

@@ -0,0 +1,205 @@
+import { after, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { appendEvent, readEvents } from "../db/events.js";
+import { initMemorySchema, prepareFtsQuery, searchHybrid, tokenizeQuery } from "../memory/storage.js";
+import { runIndex, hasUnindexedEvents } from "../memory/index.js";
+import { disposeEmbeddingModel } from "../memory/embeddings.js";
+// The embedding pipeline runs in a worker_threads Worker that keeps the
+// test process alive until terminated. Tear it down after this suite so
+// `node --test` can exit cleanly.
+after(async () => {
+    await disposeEmbeddingModel();
+});
+/** Create a test DB with migrations applied (adds archived column etc.) */
+function createSearchTestDb() {
+    const db = createTestDb();
+    // Apply migrations that createTestDb doesn't run
+    const cols = db.pragma("table_info(narratives)");
+    const colNames = new Set(cols.map((c) => c.name));
+    if (!colNames.has("archived")) {
+        db.exec("ALTER TABLE narratives ADD COLUMN archived INTEGER DEFAULT 0");
+    }
+    return db;
+}
+function insertNarrative(db, id, opts = {}) {
+    const hasArchived = db.pragma("table_info(narratives)")
+        .some((c) => c.name === "archived");
+    if (hasArchived) {
+        db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, status, summary, archived, created_at)
+       VALUES (?, 'brane-test', ?, ?, ?, ?, ?, ?)`).run(id, opts.agent_type ?? "claude", opts.role ?? "worker", opts.status ?? "active", opts.summary ?? null, opts.archived ? 1 : 0, Date.now());
+    }
+    else {
+        db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, status, summary, created_at)
+       VALUES (?, 'brane-test', ?, ?, ?, ?, ?)`).run(id, opts.agent_type ?? "claude", opts.role ?? "worker", opts.status ?? "active", opts.summary ?? null, Date.now());
+    }
+}
+describe("events endpoint limit with after", () => {
+    it("readEvents with after returns all events after cursor", () => {
+        const db = createSearchTestDb();
+        insertNarrative(db, "n1");
+        for (let i = 0; i < 20; i++) {
+            appendEvent(db, "n1", "narration", { content: `msg-${i}` });
+        }
+        // Without limit, returns all 15 events after seq 5
+        const all = readEvents(db, "n1", { after: 5 });
+        assert.equal(all.length, 15);
+    });
+    it("readEvents with after + tail caps results", () => {
+        const db = createSearchTestDb();
+        insertNarrative(db, "n1");
+        for (let i = 0; i < 20; i++) {
+            appendEvent(db, "n1", "narration", { content: `msg-${i}` });
+        }
+        // With tail, returns last N events after cursor
+        const capped = readEvents(db, "n1", { after: 5, tail: 5 });
+        assert.equal(capped.length, 5);
+        // Should be the last 5 events (seq 16-20)
+        assert.equal(capped[0].seq, 16);
+        assert.equal(capped[4].seq, 20);
+    });
+    it("readEvents with after + before provides a window", () => {
+        const db = createSearchTestDb();
+        insertNarrative(db, "n1");
+        for (let i = 0; i < 20; i++) {
+            appendEvent(db, "n1", "narration", { content: `msg-${i}` });
+        }
+        // Window: events with 5 < seq < 15
+        const windowed = readEvents(db, "n1", { after: 5, before: 15 });
+        assert.equal(windowed.length, 9); // seq 6-14
+        assert.equal(windowed[0].seq, 6);
+        assert.equal(windowed[8].seq, 14);
+    });
+});
+describe("tokenizeQuery", () => {
+    it("returns terms for bare tokens", () => {
+        assert.deepEqual(tokenizeQuery("foo bar"), [
+            { kind: "term", text: "foo" },
+            { kind: "term", text: "bar" },
+        ]);
+    });
+    it("returns a phrase for a quoted span", () => {
+        assert.deepEqual(tokenizeQuery('"foo bar"'), [
+            { kind: "phrase", text: "foo bar" },
+        ]);
+    });
+    it("mixes phrase and term tokens preserving order", () => {
+        assert.deepEqual(tokenizeQuery('"foo bar" baz'), [
+            { kind: "phrase", text: "foo bar" },
+            { kind: "term", text: "baz" },
+        ]);
+    });
+    it("recognizes smart-quote phrase pairs", () => {
+        assert.deepEqual(tokenizeQuery("“foo bar” ‘baz qux’"), [
+            { kind: "phrase", text: "foo bar" },
+            { kind: "phrase", text: "baz qux" },
+        ]);
+    });
+    it("returns empty array for empty input", () => {
+        assert.deepEqual(tokenizeQuery(""), []);
+        assert.deepEqual(tokenizeQuery("   "), []);
+    });
+});
+describe("prepareFtsQuery", () => {
+    it("bare tokens become AND of prefix-matched terms", () => {
+        assert.equal(prepareFtsQuery("foo bar"), '"foo"* "bar"*');
+    });
+    it("drops bare tokens shorter than 2 chars", () => {
+        assert.equal(prepareFtsQuery("a foo b"), '"foo"*');
+    });
+    it("returns null for empty or all-too-short input", () => {
+        assert.equal(prepareFtsQuery(""), null);
+        assert.equal(prepareFtsQuery("   "), null);
+        assert.equal(prepareFtsQuery("a b c"), null);
+    });
+    it("quoted phrase becomes an FTS5 phrase (no prefix)", () => {
+        assert.equal(prepareFtsQuery('"foo bar"'), '"foo bar"');
+    });
+    it("phrase + bare term ANDs both", () => {
+        assert.equal(prepareFtsQuery('"foo bar" baz'), '"foo bar" "baz"*');
+    });
+    it("phrase preserves short tokens that bare-token rules would drop", () => {
+        assert.equal(prepareFtsQuery('"a b"'), '"a b"');
+    });
+    it("unterminated phrase reads to end-of-input", () => {
+        assert.equal(prepareFtsQuery('foo "bar baz'), '"foo"* "bar baz"');
+    });
+    it("empty quoted span is dropped", () => {
+        assert.equal(prepareFtsQuery('"" foo'), '"foo"*');
+    });
+    it("recognizes smart double quotes as a phrase pair", () => {
+        assert.equal(prepareFtsQuery("“foo bar” baz"), '"foo bar" "baz"*');
+    });
+    it("recognizes smart single quotes as a phrase pair", () => {
+        assert.equal(prepareFtsQuery("‘foo bar’"), '"foo bar"');
+    });
+    it("does not treat ASCII apostrophe as a delimiter (preserves contractions)", () => {
+        assert.equal(prepareFtsQuery("don't stop"), `"don't"* "stop"*`);
+    });
+    it("smart-quote opener without matching closer reads to EOF", () => {
+        assert.equal(prepareFtsQuery("foo “bar baz"), '"foo"* "bar baz"');
+    });
+    it("treats `\"` as a phrase boundary even when adjacent (no escape syntax)", () => {
+        // `""hi""` is parsed as: empty phrase, then bare token `hi` (the trailing
+        // `"` ends the bare token), then another empty phrase. Empties drop out;
+        // `hi` is treated as a regular bare term.
+        assert.equal(prepareFtsQuery('""hi""'), '"hi"*');
+    });
+});
+describe("memory search", () => {
+    it("hasUnindexedEvents detects unindexed events", () => {
+        const db = createSearchTestDb();
+        initMemorySchema(db);
+        insertNarrative(db, "n1");
+        appendEvent(db, "n1", "narration", { content: "hello world" });
+        assert.equal(hasUnindexedEvents(db), true);
+    });
+    it("indexing and search finds matching content", async () => {
+        const db = createSearchTestDb();
+        initMemorySchema(db);
+        insertNarrative(db, "n1");
+        appendEvent(db, "n1", "narration", { content: "The mitochondria is the powerhouse of the cell" });
+        appendEvent(db, "n1", "narration", { content: "JavaScript is a programming language" });
+        await runIndex(db, false);
+        assert.equal(hasUnindexedEvents(db), false);
+        // Import embedText dynamically since it loads a model
+        const { embedText } = await import("../memory/embeddings.js");
+        const queryVector = await embedText("mitochondria cell biology");
+        const results = searchHybrid(db, queryVector, "mitochondria cell biology", 10);
+        assert.ok(results.length > 0, "Should find at least one result");
+        assert.ok(results[0].content.includes("mitochondria"), "Top result should be about mitochondria");
+    });
+    it("phrase match outranks bare-keyword match", async () => {
+        const db = createSearchTestDb();
+        initMemorySchema(db);
+        insertNarrative(db, "n-adj");
+        appendEvent(db, "n-adj", "narration", { content: "context compaction recovery happens after long sessions" });
+        insertNarrative(db, "n-split");
+        appendEvent(db, "n-split", "narration", { content: "context window state and unrelated compaction logic" });
+        await runIndex(db, false);
+        const { embedText } = await import("../memory/embeddings.js");
+        const queryVector = await embedText("context compaction");
+        const phrase = searchHybrid(db, queryVector, '"context compaction"', 10);
+        assert.ok(phrase.length > 0, "phrase query should return results");
+        const adj = phrase.find((r) => r.narrative_id === "n-adj");
+        const split = phrase.find((r) => r.narrative_id === "n-split");
+        assert.ok(adj, "phrase query should surface the adjacent-tokens narrative");
+        if (split) {
+            assert.ok(adj.score > split.score, `adjacent-phrase narrative should outrank split-tokens narrative ` +
+                `(adj=${adj.score}, split=${split.score})`);
+        }
+    });
+    it("search surfaces archived narratives", async () => {
+        const db = createSearchTestDb();
+        initMemorySchema(db);
+        insertNarrative(db, "n-archived", { archived: true, summary: "Old conversation" });
+        appendEvent(db, "n-archived", "narration", { content: "Quantum computing uses qubits for parallel computation" });
+        await runIndex(db, false);
+        const { embedText } = await import("../memory/embeddings.js");
+        const queryVector = await embedText("quantum computing qubits");
+        const results = searchHybrid(db, queryVector, "quantum computing qubits", 10);
+        assert.ok(results.length > 0, "Should find results from archived narrative");
+        assert.equal(results[0].narrative_id, "n-archived");
+    });
+});
+//# sourceMappingURL=search.test.js.map

package/dist/test/security.test.js

@@ -0,0 +1,48 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { resolve } from "node:path";
+describe("agent name validation", () => {
+    // Regex from doSpawn
+    const VALID_AGENT = /^[a-zA-Z0-9_-]+$/;
+    it("accepts valid agent names", () => {
+        for (const name of ["claude", "goose", "codex", "my-agent", "agent_v2"]) {
+            assert.ok(VALID_AGENT.test(name), `${name} should be valid`);
+        }
+    });
+    it("rejects shell metacharacters", () => {
+        for (const name of [
+            "agent; rm -rf /",
+            "$(whoami)",
+            "`id`",
+            "agent | cat /etc/passwd",
+            "../../../etc/passwd",
+            "agent name",
+            "agent\nnewline",
+        ]) {
+            assert.ok(!VALID_AGENT.test(name), `${name} should be rejected`);
+        }
+    });
+});
+describe("static file path traversal", () => {
+    const STATIC_DIR = "/app/expo/dist";
+    function isAllowed(urlPath) {
+        const filePath = resolve(STATIC_DIR, urlPath === "/" ? "index.html" : urlPath.replace(/^\//, ""));
+        return filePath === STATIC_DIR || filePath.startsWith(STATIC_DIR + "/");
+    }
+    it("allows normal paths", () => {
+        assert.ok(isAllowed("/"));
+        assert.ok(isAllowed("/index.html"));
+        assert.ok(isAllowed("/assets/main.js"));
+    });
+    it("blocks path traversal", () => {
+        assert.ok(!isAllowed("/../../../etc/passwd"));
+        assert.ok(!isAllowed("/.."));
+    });
+    it("blocks prefix collision", () => {
+        // If STATIC_DIR is /app/expo/dist, a path resolving to /app/expo/distevil should be blocked
+        const evil = resolve(STATIC_DIR, "../distevil/file.txt");
+        assert.ok(evil.startsWith(STATIC_DIR.slice(0, -1))); // would pass naive startsWith
+        assert.ok(!isAllowed("/../distevil/file.txt")); // but our check blocks it
+    });
+});
+//# sourceMappingURL=security.test.js.map

package/dist/test/selection-wiring.test.js

@@ -0,0 +1,61 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+// The chat's message selection lives in a store (shared/message-selection), not
+// in the screen's React state, and the difference is invisible to every test
+// that can run in node: both spellings select messages. What the store buys is
+// two things a rendered test would have to catch — a tap that wakes only the
+// bubble it changed, and two taps in the same frame that both land. The
+// `useState` spelling failed the second outright: `handleTimestampPress` closed
+// over `selectedSeqs`, so the second tap computed from the set the first had
+// already replaced and silently undid it (observed in a headless browser: two
+// rapid taps left one message selected).
+//
+// So this reads the source, the way key-routing.test.ts does, and holds the
+// screen to the wiring.
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const SCREEN = join("expo", "app", "[nid].tsx");
+const read = (rel) => readFileSync(join(repoRoot, rel), "utf8");
+// Lints source the tarball doesn't ship, so an installed package skips rather
+// than failing on ENOENT (`brane doctor` runs this suite).
+const skip = !existsSync(join(repoRoot, SCREEN)) ? "expo source not shipped" : false;
+describe("the chat's message selection is a store, not screen state", () => {
+    test("the screen holds no selection state", { skip }, () => {
+        const src = read(SCREEN);
+        assert.ok(!/useState<Set<number>>/.test(src), "a Set in useState is the shape this replaced: it re-renders the screen, which rebuilds renderItem, which re-renders every bubble");
+        assert.match(src, /useMessageSelection\(/, "the screen creates the selection store");
+    });
+    test("the toggle closes over the store, not over the selection", { skip }, () => {
+        const src = read(SCREEN);
+        const press = src.match(/const handleTimestampPress = useCallback\([\s\S]*?\}, \[([^\]]*)\]\);/);
+        assert.ok(press, "handleTimestampPress must be a useCallback with a dependency list");
+        const deps = press[1].split(",").map((d) => d.trim()).filter(Boolean);
+        assert.deepEqual(deps.filter((d) => d !== "router" && d !== "selection"), [], "any dependency that changes with the selection rebuilds every bubble's callback prop");
+    });
+    test("renderItem hands the bubble the store, not a boolean", { skip }, () => {
+        const src = read(SCREEN);
+        assert.match(src, /selection=\{selection\}/, "the bubble subscribes for itself");
+        assert.ok(!/selected=\{[^}]*\.has\(/.test(src), "a computed `selected` prop puts the whole list back on the selection's re-render path");
+    });
+    test("the bubble subscribes to its own seq", { skip }, () => {
+        const src = read(SCREEN);
+        assert.match(src, /useIsSelected\(selection, item\.seq\)/);
+    });
+    test("a send consumes the selection through handleDeselect, URL included", { skip }, () => {
+        // `?scrollToSeq=` is what makes a selection survive a reload, so a send
+        // that clears only the store leaves the param behind: a reload, Isolate or
+        // Meld re-selects the message just answered, and the next signal silently
+        // carries the old `re` again. `handleDeselect` clears both.
+        const src = read(SCREEN);
+        const send = src.match(/const handleSend = useCallback\([\s\S]*?\n  \}, \[[^\]]*\]\);/);
+        assert.ok(send, "handleSend must be a useCallback with a dependency list");
+        assert.match(send[0], /onDeselect\(\)/, "the send hands the clear to the screen's handleDeselect");
+        assert.ok(!/selection\.clear\(\)/.test(send[0]), "clearing the store alone strands ?scrollToSeq=");
+        assert.match(src, /<InputBar[\s\S]*?onDeselect=\{handleDeselect\}/, "the composer is given handleDeselect");
+        const deselect = src.match(/const handleDeselect = useCallback\([\s\S]*?\}, \[[^\]]*\]\);/);
+        assert.ok(deselect && /scrollToSeq: undefined/.test(deselect[0]), "handleDeselect clears the param");
+    });
+});
+//# sourceMappingURL=selection-wiring.test.js.map