@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/dist/esm/main/file-attachments.test.js

@@ -1,164 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { FoundationAiAssistant } from './main';
-// Hold a reference so the custom-element registration isn't tree-shaken.
-FoundationAiAssistant;
-// GENC-1508 — image files become IMAGE attachments, not text.
-//
-// `processFiles` read every accepted file with `readAsText`, so an accepted .png
-// arrived as mojibake the model "read" as prose — an accepted image was worse than a
-// rejected one. The layout-apply flow attaches the picked mockup's PNG beside its
-// spec, which is what forced the branch: images now read as base64 and ship as
-// `{kind:'image'}`, the shape the transports render as real image blocks.
-//
-// Unconnected elements (createElement upgrades but does not connect), same as
-// blocked-state.test.ts — processFiles touches no session state.
-const Suite = createLogicSuite('FoundationAiAssistant file attachments');
-function element(acceptedFiles) {
-    const el = document.createElement('foundation-ai-assistant');
-    el.chatConfig = { ui: { acceptedFiles } };
-    return el;
-}
-/** A tiny valid PNG header is unnecessary — processFiles never parses pixels. */
-const PNG_BYTES = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
-Suite('an accepted image file becomes a kind:image attachment with raw base64', () => __awaiter(void 0, void 0, void 0, function* () {
-    const el = element('.md,image/*');
-    const { attachments, errors } = yield el.processFiles([
-        new File([PNG_BYTES], 'layout-mockup.png', { type: 'image/png' }),
-    ]);
-    assert.equal(errors, []);
-    const [img] = attachments;
-    assert.is(img.kind, 'image');
-    assert.is(img.name, 'layout-mockup.png');
-    assert.is(img.mimeType, 'image/png');
-    // RAW base64 — a `data:` prefix left on would be sent to the vendor inside the payload.
-    assert.ok(img.data && !img.data.startsWith('data:'), 'data must be bare base64');
-    assert.is(atob(img.data).length, PNG_BYTES.length);
-}));
-Suite('a text file on the same submit stays a text attachment', () => __awaiter(void 0, void 0, void 0, function* () {
-    const el = element('.md,image/*');
-    const { attachments } = yield el.processFiles([
-        new File(['# spec'], 'layout-spec.md', { type: 'text/markdown' }),
-        new File([PNG_BYTES], 'layout-mockup.png', { type: 'image/png' }),
-    ]);
-    const [text, img] = attachments;
-    assert.is(text.kind, undefined);
-    assert.is(text.content, '# spec');
-    assert.is(img.kind, 'image');
-}));
-Suite('an image type the host did not accept is still refused', () => __awaiter(void 0, void 0, void 0, function* () {
-    const el = element('.md,.txt');
-    const { attachments, errors } = yield el.processFiles([
-        new File([PNG_BYTES], 'layout-mockup.png', { type: 'image/png' }),
-    ]);
-    assert.equal(attachments, []);
-    assert.is(errors.length, 1);
-    assert.match(errors[0], /not an accepted file type/);
-}));
-// A ~70KB image: the base64 loop's chunk size is 32768, so this crosses the boundary twice.
-// The 8-byte fixture above executes the loop body exactly once, which would not notice an
-// off-by-one in the subarray bounds.
-Suite('a multi-chunk image round-trips byte-for-byte across the base64 loop', () => __awaiter(void 0, void 0, void 0, function* () {
-    const big = new Uint8Array(70000);
-    // A non-trivial pattern — an all-zero buffer survives most encoding mistakes.
-    for (let i = 0; i < big.length; i += 1)
-        big[i] = (i * 31 + (i >> 8)) & 0xff;
-    const el = element('image/*');
-    const { attachments, errors } = yield el.processFiles([
-        new File([big], 'wide.png', { type: 'image/png' }),
-    ]);
-    assert.equal(errors, []);
-    const [img] = attachments;
-    const back = atob(img.data);
-    assert.is(back.length, big.length);
-    let mismatch = -1;
-    for (let i = 0; i < big.length; i += 1) {
-        if (back.charCodeAt(i) !== big[i]) {
-            mismatch = i;
-            break;
-        }
-    }
-    assert.is(mismatch, -1, 'every byte must survive the chunked encode');
-}));
-Suite('an image over the size cap is refused by NAME and size, not sent to the vendor', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Refused here rather than at the API: a vendor 400 lands after the user has waited out the
-    // turn, and the encoded blob is persisted meanwhile — one oversized image can blow the storage
-    // quota and silently stop the session autosaving.
-    const el = element('image/*');
-    const { attachments, errors } = yield el.processFiles([
-        new File([new Uint8Array(4000000)], 'huge.png', { type: 'image/png' }),
-    ]);
-    assert.equal(attachments, []);
-    assert.is(errors.length, 1);
-    assert.match(errors[0], /huge\.png/);
-    assert.match(errors[0], /limited to/);
-}));
-Suite('an image type the vendors do not accept falls back to TEXT, never a failed turn', () => __awaiter(void 0, void 0, void 0, function* () {
-    // `image/*` covers HEIC, BMP, TIFF, SVG — none of which the APIs take, and sending one fails
-    // the whole turn. SVG especially: it IS text, so the text branch gives the model something it
-    // can actually read.
-    const el = element('image/*');
-    const { attachments, errors } = yield el.processFiles([
-        new File(['<svg xmlns="http://www.w3.org/2000/svg"><rect /></svg>'], 'icon.svg', {
-            type: 'image/svg+xml',
-        }),
-        new File([new Uint8Array([0, 1, 2, 3])], 'photo.heic', { type: 'image/heic' }),
-    ]);
-    assert.equal(errors, []);
-    const [svg, heic] = attachments;
-    assert.is(svg.kind, undefined, 'SVG stays text — a model can read it');
-    assert.match(svg.content, /<rect/);
-    assert.is(heic.kind, undefined, 'an unsupported binary degrades rather than failing the turn');
-}));
-Suite('every supported spelling takes the image branch, including image/jpg', () => __awaiter(void 0, void 0, void 0, function* () {
-    const el = element('image/*');
-    const { attachments } = yield el.processFiles(['image/png', 'image/jpeg', 'image/jpg', 'image/gif', 'image/webp'].map((type, i) => new File([PNG_BYTES], `f${i}`, { type })));
-    assert.equal(attachments.map((a) => a.kind), ['image', 'image', 'image', 'image', 'image']);
-}));
-// The TOTAL, not just each file. `loadSelectedFiles` appends across successive picks and the
-// per-file check is blind to what is already attached, so ten files each just under the per-image
-// ceiling used to be ten passes and one ~34MB request — assembled entirely out of files that each
-// passed. Reviewer catch on #2474.
-Suite('the file that crosses the total is refused; the ones that fit are kept', () => __awaiter(void 0, void 0, void 0, function* () {
-    const el = element('image/*');
-    const mb = (n) => new Uint8Array(n * 1000000);
-    const { attachments, errors } = yield el.processFiles([
-        new File([mb(3)], 'a.png', { type: 'image/png' }),
-        new File([mb(3)], 'b.png', { type: 'image/png' }),
-        new File([mb(3)], 'c.png', { type: 'image/png' }), // 9MB total — past the 8MB ceiling
-    ]);
-    assert.is(attachments.length, 2, 'the two that fit are accepted');
-    assert.is(errors.length, 1);
-    assert.match(errors[0], /c\.png/);
-    assert.match(errors[0], /attachment limit/);
-}));
-Suite('the budget counts what is ALREADY attached, not just this pick', () => __awaiter(void 0, void 0, void 0, function* () {
-    // The picker's second pick has to see the first one's bytes, or "under the limit" is measured
-    // against zero every time and the limit means nothing.
-    const el = element('image/*');
-    const fresh = yield el.processFiles([
-        new File([new Uint8Array(3000000)], 'a.png', { type: 'image/png' }),
-    ]);
-    assert.is(fresh.attachments.length, 1, 'fits on its own');
-    const withHistory = yield el.processFiles([new File([new Uint8Array(3000000)], 'b.png', { type: 'image/png' })], 6000000);
-    assert.is(withHistory.attachments.length, 0, 'the same file is refused once 6MB is already committed');
-    assert.match(withHistory.errors[0], /6\.0MB already attached/);
-}));
-Suite('a refusal skips only the offending file — a later one that still fits is kept', () => __awaiter(void 0, void 0, void 0, function* () {
-    // Budgeted synchronously off `file.size`, in the user's own pick order, before anything is read
-    // (deciding inside the parallel reads would hand the last slot to whichever finished first).
-    // A file that does not fit is refused and the budget carries on, so a smaller one behind it is
-    // not punished for its neighbour.
-    const el = element('image/*');
-    const mb = (n) => new Uint8Array(n * 1000000);
-    const { attachments, errors } = yield el.processFiles([
-        new File([mb(3)], 'a.png', { type: 'image/png' }), // running 3
-        new File([mb(3)], 'b.png', { type: 'image/png' }), // running 6
-        new File([mb(3)], 'big.png', { type: 'image/png' }), // 9 > 8 — refused
-        new File([mb(1)], 'small.png', { type: 'image/png' }), // 7 — still fits
-    ]);
-    assert.equal(attachments.map((a) => a.name), ['a.png', 'b.png', 'small.png']);
-    assert.is(errors.length, 1);
-    assert.match(errors[0], /big\.png/);
-}));
-Suite.run();

package/dist/esm/main/interaction-cost.test.js

@@ -1,107 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { getSessionStore } from '../state/session-store';
-import { FoundationAiAssistant } from './main';
-// Hold a reference so the custom-element registration isn't tree-shaken.
-FoundationAiAssistant;
-// GENC-1508 — the host hop of the post-resolve cost channel.
-//
-// The driver method and the orchestrator delegation both have tests; this pins the hop
-// between them, which is the one most likely to break silently: a rename on either side of
-// `handleInteractionCost` is a no-op that every other test still passes, and the "no spinner"
-// guarantee is a design promise stated only in a comment.
-//
-// Unconnected element (createElement upgrades but does not connect), same as
-// blocked-state.test.ts — this handler touches no session state.
-const Suite = createLogicSuite('FoundationAiAssistant interaction cost');
-function host() {
-    const el = document.createElement('foundation-ai-assistant');
-    const calls = [];
-    const state = { spinners: 0 };
-    el.driver = {
-        recordExternalCost: (id, cost) => {
-            calls.push([id, cost]);
-            return true;
-        },
-    };
-    el.startLoadingTimer = () => {
-        state.spinners += 1;
-    };
-    return {
-        el,
-        calls,
-        get spinners() {
-            return state.spinners;
-        },
-    };
-}
-const costEvent = (detail) => new CustomEvent('interaction-cost', { detail });
-Suite('a cost report reaches the driver', () => {
-    const h = host();
-    h.el.handleInteractionCost(costEvent({ interactionId: 'abc', costUsd: 0.42 }));
-    assert.equal(h.calls, [['abc', 0.42]]);
-});
-Suite('reporting cost NEVER starts the loading spinner', () => {
-    // The whole point of the channel: this is bookkeeping about a turn that already finished, so
-    // it must be invisible. A spinner would tell the user the assistant is working when nothing
-    // is pending — the one thing `handleInteractionCompleted` does that this must not copy.
-    const h = host();
-    h.el.handleInteractionCost(costEvent({ interactionId: 'abc', costUsd: 0.42 }));
-    assert.is(h.spinners, 0);
-});
-Suite('an event with no interactionId is ignored', () => {
-    const h = host();
-    h.el.handleInteractionCost(costEvent({ costUsd: 0.42 }));
-    h.el.handleInteractionCost(costEvent(undefined));
-    assert.equal(h.calls, []);
-});
-Suite('a driver that does not implement the optional method is not called into', () => {
-    // `recordExternalCost` is optional on `AiDriver`, so a driver predating this — or one that
-    // simply does not track spend — must be ignored rather than throw.
-    const h = host();
-    h.el.driver = {};
-    assert.not.throws(() => h.el.handleInteractionCost(costEvent({ interactionId: 'a', costUsd: 1 })));
-    h.el.driver = undefined;
-    assert.not.throws(() => h.el.handleInteractionCost(costEvent({ interactionId: 'a', costUsd: 1 })));
-});
-Suite('a driver without the method leaves a TRACE, not a silent no-op', () => {
-    // Reviewer catch on #2474: every other hop traces its drops. A driver predating
-    // `recordExternalCost` made this one a silent no-op — money gone, nothing recorded — which is
-    // the invisible gap the whole channel exists to close, reintroduced at the last hop.
-    const h = host();
-    const meta = [];
-    h.el.logMeta = (t, d) => {
-        meta.push([t, d]);
-    };
-    h.el.driver = {};
-    h.el.handleInteractionCost(costEvent({ interactionId: 'abc', costUsd: 0.42 }));
-    assert.is(meta.length, 1);
-    assert.is(meta[0][0], 'interaction.external-cost-dropped');
-    assert.is(meta[0][1].costUsd, 0.42);
-    assert.is(meta[0][1].interactionId, 'abc');
-});
-// The OUTBOUND half: the driver announced, and the host has to turn that into a moved number.
-// Tested because it is the same shape of hop as the one that already went wrong — the wrapper
-// forward that was missing — and because it deliberately reads the DRIVER's history rather than
-// `this.messages`, which is the part a reader would most likely "simplify" back.
-let storeSeq = 0;
-/** An element wired to its own real session store, so `sessionUsage` round-trips. */
-function costHost() {
-    const el = document.createElement('foundation-ai-assistant');
-    storeSeq += 1;
-    el._sessionRef = getSessionStore(`cost-test-${(storeSeq += 1)}`, false);
-    return el;
-}
-Suite('the recorded spend reaches the session total from the DRIVER history', () => {
-    const el = costHost();
-    const sync = el.syncUsageTotals.bind(el);
-    sync([{ role: 'assistant', content: 'a', cost: 0.1, model: 'claude-sonnet-5' }]);
-    assert.is(el.sessionCostUsd, 0.1);
-    // The post-resolve delta lands on the interaction message as `externalCostUsd`; the total has
-    // to fold it in, or every hop before this one was wasted.
-    sync([
-        { role: 'assistant', content: 'a', cost: 0.1, model: 'claude-sonnet-5' },
-        { role: 'assistant', content: 'b', externalCostUsd: 0.25 },
-    ]);
-    assert.is(el.sessionCostUsd, 0.35);
-});
-Suite.run();

package/dist/esm/main/main.styles.test.js

@@ -1,161 +0,0 @@
-var _a, _b, _c, _d, _e, _f, _g;
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { foregroundOnAccentRest, neutralLayer2 } from '@genesislcap/foundation-ui';
-import { styles } from './main.styles';
-// CSS is not otherwise unit-tested in this package, so this covers the two
-// properties of the BLOCKED BANNER that are cheap to assert from the generated
-// text and that a reviewer had to catch by eye:
-//
-//   1. Design-system tokens are consumed UNFALLBACKED, as every other rule in the
-//      file does. A `var(--token, fallback)` here is dead code at best — both
-//      tokens below ship with defaults — and actively wrong at worst: the blocked
-//      banner's old `var(--neutral-layer-2, transparent)` would, if it ever fired,
-//      have produced a banner with no surface at all.
-//   2. The blocked banner's visual treatment hangs off `.is-visible`, not the bare
-//      class, because the container stays mounted while unblocked so that its
-//      `role="status"` region is registered before the text arrives (see
-//      main.template.ts). Collapsing the empty container would undo that.
-//
-// Scope: the banner's own rules, and nothing else. Both negative assertions were
-// written for one component, but an earlier version grepped the WHOLE stylesheet
-// — quietly turning a banner test into a global style policy nobody agreed to, so
-// any future rule anywhere in an 800-line sheet that legitimately wanted a
-// fallback on either token would have failed a test named after the banner.
-//
-// A second suite at the bottom covers the user bubble's fill/foreground token
-// pairing, which failed the same way a reviewer's eye does (GENC-1491).
-const suite = createLogicSuite('main.styles blocked-banner rules');
-/**
- * The generated stylesheet text. `css` composes nested `ElementStyles` (this file
- * builds the sheet from several partials), so flatten recursively rather than
- * only reading the top level — a shallow read silently returns almost nothing,
- * which would make every `assert.not.ok` below pass vacuously. The first test
- * guards exactly that.
- */
-const flatten = (value) => {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.map(flatten).join('\n');
-    const nested = value === null || value === void 0 ? void 0 : value.styles;
-    return nested ? flatten(nested) : '';
-};
-const cssText = flatten(styles);
-/**
- * Every declaration block whose selector mentions `.blocked-banner`, joined.
- *
- * Deliberately crude — one regex over the generated text, no CSS parser — but
- * enough to keep these assertions about the banner rather than about the whole
- * sheet, which was the only thing wrong with them. It matches
- * `<selector> { <declarations> }` for any selector containing `.blocked-banner`,
- * so it picks up the bare class, the `.is-visible` / `.is-partial` modifiers, the
- * shared composer-width group and the copy inside the container query alike.
- */
-const bannerRules = ((_a = cssText.match(/[^{}]*\.blocked-banner[^{}]*\{[^}]*\}/g)) !== null && _a !== void 0 ? _a : []).join('\n');
-/** Declarations of the bare-class rule — the one that applies while empty. */
-const emptyStateRule = (_c = (_b = cssText.match(/[\s{}](\.blocked-banner)\s*\{([^}]*)\}/)) === null || _b === void 0 ? void 0 : _b[2]) !== null && _c !== void 0 ? _c : '';
-suite('the banner rules were extracted as text (guards the assertions below)', () => {
-    assert.ok(cssText.includes('.blocked-banner'), 'the banner rules are in the sheet');
-    assert.ok(bannerRules.includes('.is-visible'), 'the extraction found the modifier rules');
-    assert.ok(emptyStateRule.length > 0, 'and isolated the bare-class rule');
-});
-suite('the banner consumes design-system tokens without dead fallbacks', () => {
-    assert.not.ok(bannerRules.includes('var(--neutral-layer-2,'), '--neutral-layer-2 has a DS default and is used unfallbacked everywhere else here');
-    assert.not.ok(bannerRules.includes('var(--warning-color,'), '--warning-color has a DS default and is used unfallbacked by toast/badge styles');
-});
-suite('the blocked banner keeps its unblocked container visually inert', () => {
-    // `::part(blocked-banner)` matches at all times, so the empty state must set
-    // nothing that reserves space — and must not remove the container from the
-    // accessibility tree, which is where the `role="status"` region is registered.
-    //
-    // Asserted against the bare-class rule's own declarations rather than by
-    // grepping for a `:empty` selector nobody wrote: this catches the mistake as it
-    // would actually be made — a padding or border creeping onto the always-present
-    // container — instead of one specific spelling of it.
-    //
-    // `margin-block` rather than `margin`: the shared composer-width group sets
-    // `margin-inline: auto` on the banner along with the rest of the composer
-    // column, which centres it and reserves nothing.
-    assert.ok(cssText.includes('.blocked-banner.is-visible'), 'visuals hang off is-visible');
-    for (const property of ['display: none', 'padding', 'border', 'background', 'margin-block']) {
-        assert.not.ok(emptyStateRule.includes(property), `the always-present container must not set ${property} — that is .is-visible's job`);
-    }
-});
-suite('the visible banner hands its end margin to the resize handle', () => {
-    // Reviewer's manual-testing note: the banner's block-end margin plus the 7px
-    // handle stacked into a gap the hover pill was NOT centred in (it centres in
-    // the handle alone). The adjacency rule collapses the two so the handle IS
-    // the gap. What gets pinned is the INVARIANT, not the selector's existence:
-    // both rules must read the ONE shared token, because the cancellation only
-    // works while the banner's margin and the handle's pull are equal-and-
-    // opposite — two hand-kept magnitudes ~80 lines apart regress silently, and
-    // an existence-only assertion stayed green while they did.
-    assert.ok(/:host\s*\{[^}]*--blocked-banner-gap:/.test(cssText), 'the shared gap token is declared on the host (a sibling cannot read one on the banner)');
-    assert.ok(/\.blocked-banner\.is-visible\s*\{[^}]*margin-block:\s*var\(--blocked-banner-gap\)/.test(cssText), "the banner's block margin IS the token");
-    assert.ok(/\.blocked-banner\.is-visible \+ \.composer-resize-handle\s*\{[^}]*margin-block-start:\s*calc\(var\(--blocked-banner-gap\) \* -1\)/.test(cssText), 'and the handle pulls up by exactly that token, negated — equal and opposite by construction');
-});
-suite('partial exhaustion has its own modifier, layered on the visible state', () => {
-    // `.is-visible` carries the layout and surface for BOTH states; `.is-partial`
-    // only softens it. Additive, never a replacement — so host CSS keyed on the
-    // visible state needs to know nothing about partial exhaustion.
-    assert.ok(cssText.includes('.blocked-banner.is-partial'), 'the partial modifier exists');
-});
-suite.run();
-// ─── User message bubble ──────────────────────────────────────────────────────
-const bubble = createLogicSuite('main.styles user-message colour pairing');
-/** Declarations of the `.message.user` rule — the accent-filled bubble. */
-const userMessageRule = (_e = (_d = cssText.match(/\.message\.user\s*\{([^}]*)\}/)) === null || _d === void 0 ? void 0 : _d[1]) !== null && _e !== void 0 ? _e : '';
-bubble('the user bubble pairs its accent fill with the on-accent foreground', () => {
-    // The bubble fills with --accent-fill-rest, so its text MUST come from the
-    // design system's paired on-accent token. This shipped as
-    // `--accent-foreground-on-accent-rest` — a name nothing defines — and the
-    // failure was invisible in review and in dark mode: `color` is inherited, so an
-    // undefined custom property with no fallback is invalid at computed-value time
-    // and quietly leaves the text at the inherited neutral foreground. That reads
-    // white-ish on a dark app (looks intentional) and near-black on a light one,
-    // where it landed at ~1.3:1 against the fill (GENC-1491).
-    //
-    // Asserted against the token object's OWN cssCustomProperty rather than a
-    // repeated string literal: a typo here cannot agree with itself, and a rename
-    // in the design system fails this test instead of silently reintroducing the
-    // inherit.
-    assert.ok(userMessageRule.length > 0, 'the .message.user rule is in the sheet');
-    assert.ok(userMessageRule.includes('var(--accent-fill-rest)'), 'the bubble is filled from the accent token (the premise of the pairing)');
-    assert.ok(userMessageRule.includes(`color: var(${foregroundOnAccentRest.cssCustomProperty})`), `the text colour is ${foregroundOnAccentRest.cssCustomProperty}, which the design system defines`);
-});
-bubble.run();
-// ─── Composer divider ─────────────────────────────────────────────────────────
-const divider = createLogicSuite('main.styles composer divider');
-/** Declarations of the `.composer-bar` rule — the hairline between input and controls. */
-const composerBarRule = (_g = (_f = cssText.match(/\.composer-bar\s*\{([^}]*)\}/)) === null || _f === void 0 ? void 0 : _f[1]) !== null && _g !== void 0 ? _g : '';
-divider('the divider is opt-in, and its default hides it without collapsing it', () => {
-    // Two things have to hold together, and only one of them is visible in review.
-    //
-    // 1. The line is always DRAWN — a host enabling `--ai-composer-divider` must get
-    //    a colour change, not a 1px reflow of the whole control bar. So the rule
-    //    declares a real border and hides it by painting it the composer's own
-    //    surface colour, rather than omitting the border and adding it back later.
-    //
-    // 2. That default colour has to name a token the design system actually
-    //    defines. An earlier revision reached for `--neutral-stroke-divider`, which
-    //    nothing defines: with no fallback the declaration is invalid at
-    //    computed-value time, the whole shorthand is dropped, and the divider silently
-    //    does not render — identically in both themes, which is why it survived review.
-    //    (The user bubble suite above documents the same failure, GENC-1491.)
-    //
-    // Asserted against the token object's own cssCustomProperty rather than a repeated
-    // string literal: a typo cannot agree with itself, and a design-system rename fails
-    // here instead of quietly deleting the line again.
-    assert.ok(composerBarRule.length > 0, 'the .composer-bar rule is in the sheet');
-    assert.ok(composerBarRule.includes(`border-top: 1px solid var(--ai-composer-divider, var(${neutralLayer2.cssCustomProperty}))`), `the divider is declared, opt-in via --ai-composer-divider, defaulting to ${neutralLayer2.cssCustomProperty}`);
-});
-divider('the invisible default matches the surface it sits on', () => {
-    var _a, _b;
-    // The hiding trick only works while the fallback colour IS the composer's
-    // background. If one moves off --neutral-layer-2 and the other doesn't, the
-    // "invisible" divider becomes a visible line nobody asked for.
-    const composerRule = (_b = (_a = cssText.match(/[\s{}]\.composer\s*\{([^}]*)\}/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
-    assert.ok(composerRule.length > 0, 'the .composer rule is in the sheet');
-    assert.ok(composerRule.includes(`background-color: var(${neutralLayer2.cssCustomProperty})`), 'the composer surface is the same token the divider defaults to');
-});
-divider.run();

package/dist/esm/main/persistence-broken-sources.test.js

@@ -1,180 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { DOM } from '@genesislcap/web-core';
-import { FoundationAiAssistant } from './main';
-// Hold a reference so the custom-element registration isn't tree-shaken.
-FoundationAiAssistant;
-// GENC-1511 — the blocking "not saving" modal has MORE THAN ONE reporter: this element's own
-// session persister (`sessions/<key>`), and a host reporting its own keyspaces through the public
-// API (Create's `projects/<id>.json`, which holds the app rather than the transcript).
-//
-// It was first built on a single `persistenceBroken` boolean, and review caught what that costs:
-// whichever reporter recovered FIRST closed the modal for both, and the host's own re-entry guard
-// then kept it from ever being raised again. This suite pins the per-source behaviour so that
-// collision cannot come back.
-//
-// Like `blocked-state.test.ts`, this exercises the METHODS the template bindings read rather than
-// the rendered DOM: `document.createElement` upgrades the element (constructor) without connecting
-// it, so `connectedCallback` never runs and nothing subscribes to `agenticActivityBus` — which
-// would otherwise hold the test runner's event loop open.
-const Suite = createLogicSuite('FoundationAiAssistant persistence-broken sources');
-/** A fresh, unconnected element. Nothing here needs a session store. */
-const element = () => document.createElement('foundation-ai-assistant');
-/** The modal's visible copy, as the template bindings read it. */
-const copy = (el) => ({
-    broken: el.persistenceBroken,
-    message: el.persistenceBrokenMessage,
-    detail: el.persistenceBrokenDetail,
-});
-const SESSION = 'session';
-const PROJECT = 'project';
-Suite('a single reporter raises and withdraws its own warning', () => {
-    const el = element();
-    assert.is(el.persistenceBroken, false);
-    el.reportPersistenceBroken({ detail: '2 messages have not been saved.', source: SESSION });
-    assert.is(el.persistenceBroken, true);
-    assert.is(el.persistenceBrokenDetail, '2 messages have not been saved.');
-    el.reportPersistenceRecovered(SESSION);
-    assert.is(el.persistenceBroken, false);
-    assert.is(el.persistenceBrokenMessage, undefined);
-    assert.is(el.persistenceBrokenDetail, undefined);
-});
-Suite('one source recovering does NOT withdraw another still-broken source', () => {
-    const el = element();
-    el.reportPersistenceBroken({ detail: 'session detail', source: SESSION });
-    el.reportPersistenceBroken({ message: 'project copy', source: PROJECT });
-    // The session's own save lands. Its warning goes; the project's must not.
-    el.reportPersistenceRecovered(SESSION);
-    assert.is(el.persistenceBroken, true, 'modal must stay up while the project store is failing');
-    assert.is(el.persistenceBrokenMessage, 'project copy', 'and must still describe THAT failure');
-    el.reportPersistenceRecovered(PROJECT);
-    assert.is(el.persistenceBroken, false, 'only once nothing is broken');
-});
-Suite('a later report does not overwrite an earlier source with its own copy', () => {
-    const el = element();
-    el.reportPersistenceBroken({
-        message: 'project copy',
-        detail: 'project detail',
-        source: PROJECT,
-    });
-    // The session reports with NO message override — it wants the template's session default.
-    // Before per-source tracking this assigned `undefined` over the project wording, so the modal
-    // claimed "this session has stopped saving" about a failed PROJECT write.
-    el.reportPersistenceBroken({ detail: 'session detail', source: SESSION });
-    assert.is(el.persistenceBrokenMessage, undefined, 'newest source wins while it is broken');
-    assert.is(el.persistenceBrokenDetail, 'session detail');
-    // ...and when the newest recovers, the copy falls BACK to the survivor rather than staying
-    // on the recovered source's wording (or reverting to the default).
-    el.reportPersistenceRecovered(SESSION);
-    assert.is(el.persistenceBrokenMessage, 'project copy');
-    assert.is(el.persistenceBrokenDetail, 'project detail');
-    assert.is(el.persistenceBroken, true);
-});
-Suite('recovering an unknown or already-recovered source is a no-op', () => {
-    const el = element();
-    el.reportPersistenceBroken({ message: 'project copy', source: PROJECT });
-    el.reportPersistenceRecovered(SESSION); // never reported
-    assert.equal(copy(el), { broken: true, message: 'project copy', detail: undefined });
-    el.reportPersistenceRecovered(PROJECT);
-    el.reportPersistenceRecovered(PROJECT); // twice
-    assert.equal(copy(el), { broken: false, message: undefined, detail: undefined });
-});
-Suite('re-reporting the same source refreshes its copy without duplicating it', () => {
-    const el = element();
-    el.reportPersistenceBroken({ detail: '2 messages have not been saved.', source: SESSION });
-    el.reportPersistenceBroken({ detail: '5 messages have not been saved.', source: SESSION });
-    assert.is(el.persistenceBrokenDetail, '5 messages have not been saved.');
-    // One recovery must clear it — a second entry for the same source would leave it stuck on.
-    el.reportPersistenceRecovered(SESSION);
-    assert.is(el.persistenceBroken, false);
-});
-Suite('a host that omits the source gets a default it can still recover', () => {
-    const el = element();
-    el.reportPersistenceBroken({ message: 'host copy' });
-    assert.is(el.persistenceBroken, true);
-    el.reportPersistenceRecovered();
-    assert.is(el.persistenceBroken, false);
-});
-Suite("a host's default source is independent of the session's", () => {
-    const el = element();
-    el.reportPersistenceBroken({ detail: 'session detail', source: SESSION });
-    el.reportPersistenceBroken({ message: 'host copy' });
-    el.reportPersistenceRecovered(); // the host's
-    assert.is(el.persistenceBroken, true, 'the session failure is still live');
-    assert.is(el.persistenceBrokenDetail, 'session detail');
-});
-// GENC-1511 (PR #2472 review) — the deferred show is a separate race from the source tracking.
-// `persistenceBrokenChanged` queues the show via `DOM.queueUpdate`, and the queued callback used
-// not to re-read the flag. A `true → false` inside the same batch runs the `!broken` branch against
-// a modal that was never shown (both statements no-op), and the callback then raised a blocking,
-// NON-DISMISSIBLE modal for a problem that had already fixed itself — with no further change event
-// left to close it, so the only way out was a reload nobody needed.
-//
-// Reachable because `maybeReportBroken` fires before `provider.save` in `persistSession`, so a
-// report and the write that withdraws it can share a tick.
-/** Minimal stand-in for the design-system modal, recording what the callback did to it. */
-function modalStub() {
-    const calls = { show: 0, close: 0 };
-    const dialog = document.createElement('dialog');
-    return {
-        calls,
-        modal: {
-            open: false,
-            mainElement: dialog,
-            show() {
-                calls.show += 1;
-                this.open = true;
-            },
-            close() {
-                calls.close += 1;
-                this.open = false;
-            },
-        },
-    };
-}
-/**
- * Drain the FAST update queue SYNCHRONOUSLY.
- *
- * `DOM.processUpdates()` and not an `await setTimeout(0)`: the queue lands on
- * `requestAnimationFrame`, which a zero-delay timer does not reliably cover. A timer-based flush
- * made these tests pass or fail on scheduling luck — the "does not show" assertion passed for the
- * wrong reason, and its positive control passed only because earlier tests had pumped the queue.
- */
-const flush = () => DOM.processUpdates();
-const withModal = (el, modal) => {
-    el.persistenceModal = modal;
-};
-// POSITIVE CONTROL for the test below. Without it, a queue that never drains in this environment
-// would make the "does not show" assertion pass for entirely the wrong reason.
-Suite('the deferred show DOES raise the modal when the failure is still live', () => {
-    const el = element();
-    const { calls, modal } = modalStub();
-    withModal(el, modal);
-    el.reportPersistenceBroken({ detail: 'session detail', source: SESSION });
-    flush();
-    assert.is(calls.show, 1, 'precondition: the queued callback runs in this environment');
-    assert.is(modal.open, true);
-});
-Suite('a recovery inside the same batch cancels the deferred show', () => {
-    const el = element();
-    const { calls, modal } = modalStub();
-    withModal(el, modal);
-    el.reportPersistenceBroken({ detail: 'session detail', source: SESSION });
-    el.reportPersistenceRecovered(SESSION); // lands before the queue flushes
-    flush();
-    assert.is(el.persistenceBroken, false);
-    assert.is(calls.show, 0, 'must not raise a blocking modal for a resolved failure');
-    assert.is(modal.open, false);
-});
-Suite('a recovery of ONE source still shows for the source left broken', () => {
-    const el = element();
-    const { calls, modal } = modalStub();
-    withModal(el, modal);
-    el.reportPersistenceBroken({ detail: 'session detail', source: SESSION });
-    el.reportPersistenceBroken({ message: 'project copy', source: PROJECT });
-    el.reportPersistenceRecovered(SESSION);
-    flush();
-    assert.is(el.persistenceBroken, true);
-    assert.is(calls.show, 1, 'the project failure still warrants the modal');
-    assert.is(el.persistenceBrokenMessage, 'project copy');
-});
-Suite.run();