@north-light/crouter 0.3.154

package/dist/clients/attach/__tests__/diagram.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/diagram.test.js

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { ensureRenderer, isRendererReady } from '@crouton-kit/humanloop';
+import { transformDiagramFences } from '../render/diagram.js';
+// This asserts a REAL termrender render (box-drawing glyphs), so it only holds
+// once the managed renderer is provisioned — true in the full tier and on a dev
+// box, but the fast tier is deliberately termrender-free (no uv to provision the
+// venv). Skip cleanly when the renderer is unavailable, exactly as the tmux
+// tests skip when tmux is absent, rather than failing on the environment.
+ensureRenderer();
+const SKIP = !isRendererReady() ? 'termrender renderer unavailable' : false;
+const APPLET_CONCIERGE_FLOW = `\`\`\`mermaid
+flowchart LR
+    U[User] --> C[Applet concierge]
+    C --> B[Applet-builder developer node<br/>cwd = app repo]
+    B --> D[Platform deploy command]
+    D --> B
+    B --> C
+    C --> U
+\`\`\``;
+test('renders the applet concierge flowchart after provisioning termrender', { skip: SKIP }, () => {
+    const rendered = transformDiagramFences(APPLET_CONCIERGE_FLOW, 200);
+    assert.match(rendered, /Applet-builder/);
+    assert.match(rendered, /cwd = app repo/);
+    assert.match(rendered, /Platform deploy/);
+    assert.match(rendered, /[\u2500-\u259F\u25A0-\u25FF]/);
+    assert.doesNotMatch(rendered, /```mermaid/);
+});
+test('renders a Mermaid fence whose closing marker is Markdown-indented', { skip: SKIP }, () => {
+    const source = `\`\`\`mermaid
+   gitGraph
+     commit id: "3dae8b84b (Matt)"
+     commit id: "...5 new Matt commits"
+     commit id: "3c8a9b099"
+     commit id: "our 16 rebased commits..."
+     commit id: "029d13819 ← both branches point here"
+ \`\`\``;
+    const rendered = transformDiagramFences(source, 200);
+    assert.match(rendered, /both branches point here/);
+    assert.match(rendered, /[\u2500-\u259F\u25A0-\u25FF]/);
+    assert.doesNotMatch(rendered, /```mermaid/);
+});

package/dist/clients/attach/__tests__/markdown-headings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/markdown-headings.test.js

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { initTheme } from '@earendil-works/pi-coding-agent';
+import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown } from '../render/markdown-headings.js';
+initTheme('default');
+test('keeps primary headings with pi-tui and decorates lower terminal headings without markers', () => {
+    const source = '# Title\n\n## Section\n\n### Detail\n\n#### Label';
+    const rendered = styleAttachMarkdownHeadings(source);
+    assert.match(rendered, /## Section/, 'H2 retains pi-tui’s accent treatment');
+    assert.match(rendered, /\x1b\[[^m]+mDetail/, 'H3 receives its cool terminal color');
+    assert.match(rendered, /\x1b\[[^m]+mLabel/, 'H4 receives its muted terminal color');
+    assert.doesNotMatch(rendered, /###|####/, 'decorated heading markers are omitted');
+});
+test('does not decorate Markdown examples inside fenced code', () => {
+    const source = '### Detail\n\n```md\n### Example\n#### Label\n```';
+    const rendered = styleAttachMarkdownHeadings(source);
+    assert.match(rendered, /^\x1b\[[^m]+mDetail/, 'real heading is decorated without its marker');
+    assert.match(rendered, /```md\n### Example\n#### Label\n```$/, 'fenced source remains literal');
+});
+test('copies message blocks for terminal-only decoration', () => {
+    const source = { content: [{ type: 'text', text: '### Detail' }, { type: 'toolCall', id: 't1' }] };
+    const rendered = styleAttachMessageMarkdown(source);
+    assert.notEqual(rendered, source);
+    assert.equal(source.content[0].text, '### Detail', 'broker message remains unmodified');
+    assert.match(rendered.content[0].text, /^\x1b\[[^m]+mDetail/);
+    assert.equal(rendered.content[1], source.content[1], 'non-Markdown blocks preserve identity');
+});

package/dist/clients/attach/__tests__/oauth-dialog-lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/oauth-dialog-lifecycle.test.js

@@ -0,0 +1,133 @@
+// oauth-dialog-lifecycle.test.ts — review mrf68z4h (OAuth dialog lifecycle).
+//
+// Two attach-viewer regressions, proven against a REAL InputController built from
+// minimal fakes:
+//
+//   A. An unrelated extension `notify` must NOT tear down a blocking dialog whose
+//      broker request is still pending. (The old code dismissed the active dialog
+//      on ANY notify — leaving the request unanswered in the broker and the user
+//      with no way to answer it.)
+//   B. A broker-driven `extension_ui_dismiss` (the correlated cleanup emitted when
+//      a dialog's request is aborted/timed out out-of-band) tears down ONLY the
+//      overlay whose id matches, never an unrelated one.
+//
+// Plus the same hazard for the display half of pi's uniform envelope: once
+// setStatus/setWidget/setTitle travel as `extension_ui_request`, a chrome paint
+// reaching `attachDialog` would orphan an in-flight dialog the same way (A).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { initTheme } from '@earendil-works/pi-coding-agent';
+import { InputController } from '../input/controller.js';
+// pi's ExtensionInputComponent reads the process-global theme in its constructor
+// (the broker calls initTheme() at boot); initialize it once so renderDialog can
+// build a real dialog component here.
+initTheme(undefined, false);
+function fakeEditor() {
+    const actions = new Map();
+    const obj = {
+        onSubmit: undefined,
+        onEscape: undefined,
+        onPasteImage: undefined,
+        onAction: (name, cb) => { actions.set(name, cb); },
+        getText: () => '',
+        setText: () => { },
+        addToHistory: () => { },
+        insertTextAtCursor: () => { },
+    };
+    return { obj };
+}
+/** A TUI fake whose `showOverlay` returns a handle whose `hide()` is observable,
+ *  so a test can tell whether a dialog was actually torn down. */
+function fakeTui() {
+    const hides = [];
+    let seq = 0;
+    const tui = {
+        requestRender: () => { },
+        setFocus: () => { },
+        showOverlay: () => {
+            const label = `overlay-${seq++}`;
+            return { hide: () => hides.push(label), label };
+        },
+        start: () => { },
+        stop: () => { },
+    };
+    return { tui, hides };
+}
+function buildController() {
+    const notices = [];
+    const editor = fakeEditor();
+    const { tui, hides } = fakeTui();
+    const ic = new InputController(tui, editor.obj, {}, {
+        onCommand: () => { },
+        onDialogResponse: () => { },
+        onNotice: (m) => notices.push(m),
+    });
+    return { ic, notices, hides };
+}
+const inputDialog = (id) => ({
+    type: 'extension_ui_request',
+    id,
+    method: 'input',
+    title: 'Paste the redirect URL or code',
+    placeholder: 'http://localhost/callback?...',
+});
+const notify = (message) => ({
+    type: 'extension_ui_request',
+    id: 'notify-1',
+    method: 'notify',
+    message,
+    notifyType: 'info',
+});
+test('an unrelated notify does NOT dismiss an active blocking dialog (its broker request stays live)', () => {
+    const { ic, notices, hides } = buildController();
+    ic.attachDialog(inputDialog('oauth-manual-1'));
+    assert.equal(hides.length, 0, 'the dialog overlay is up, not torn down');
+    // An unrelated extension fires a notify while the blocking dialog is showing.
+    ic.attachDialog(notify('Some unrelated background progress'));
+    assert.equal(hides.length, 0, 'the blocking dialog must remain on screen — a notify is NOT a dismissal signal');
+    assert.ok(notices.some((n) => /unrelated background progress/i.test(n)), `the notify still shows as a notice line, got: ${JSON.stringify(notices)}`);
+});
+test('a display method (setStatus) does NOT dismiss an active blocking dialog', () => {
+    const { ic, hides } = buildController();
+    ic.attachDialog(inputDialog('oauth-manual-1'));
+    assert.equal(hides.length, 0);
+    // setStatus/setWidget/setTitle ride pi's SAME `extension_ui_request` envelope.
+    // The viewer routes them to chrome before attachDialog, but a stray one
+    // reaching here must be inert — never a teardown of a live request.
+    ic.attachDialog({
+        type: 'extension_ui_request',
+        id: 'status-1',
+        method: 'setStatus',
+        statusKey: 'crtr-provider',
+        statusText: 'anthropic · ok',
+    });
+    assert.equal(hides.length, 0, 'a non-blocking display paint must not tear down the pending dialog');
+    // And the dialog is still the one the correlated dismiss addresses.
+    ic.dismissDialog('oauth-manual-1');
+    assert.equal(hides.length, 1, 'the dialog id was not clobbered by the display request');
+});
+test('extension_ui_dismiss tears down ONLY the overlay whose request id matches', () => {
+    const { ic, hides } = buildController();
+    ic.attachDialog(inputDialog('oauth-manual-1'));
+    assert.equal(hides.length, 0);
+    // A dismiss for a DIFFERENT request id must be a no-op.
+    ic.dismissDialog('some-other-request');
+    assert.equal(hides.length, 0, 'a non-matching dismiss must not tear down the current dialog');
+    // The correlated dismiss for THIS dialog's id tears it down.
+    ic.dismissDialog('oauth-manual-1');
+    assert.equal(hides.length, 1, 'the matching correlated dismiss tears down exactly the current overlay');
+    // Idempotent: a repeat dismiss (or a late one after teardown) is inert.
+    ic.dismissDialog('oauth-manual-1');
+    assert.equal(hides.length, 1, 'a repeat dismiss must not double-tear-down');
+});
+test('a new blocking dialog still supersedes the previous one (correlated dismissal remains isolated)', () => {
+    const { ic, hides } = buildController();
+    ic.attachDialog(inputDialog('dialog-a'));
+    ic.attachDialog(inputDialog('dialog-b'));
+    assert.equal(hides.length, 1, 'the first dialog is superseded (dismissed) when a second blocking dialog arrives');
+    // Now a correlated dismiss for the OLD id must not touch the current one.
+    ic.dismissDialog('dialog-a');
+    assert.equal(hides.length, 1, 'a stale dismiss for the superseded dialog does not tear down the current one');
+    ic.dismissDialog('dialog-b');
+    assert.equal(hides.length, 2, 'the current dialog is torn down by its own correlated dismiss');
+});

package/dist/clients/attach/__tests__/prompt-preview.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/prompt-preview.test.js

@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { loadedCommandPreview, parsePreviewableCommands } from '../slash/prompt-preview.js';
+test('live slash prompt preview matches pi placeholder expansion as arguments change', () => {
+    const commands = [{
+            name: 'author',
+            source: 'template',
+            description: 'develop a change',
+            template: 'Task: $ARGUMENTS\nFirst: $1\nRest: ${@:2}\nDefault: ${3:-none}',
+        }];
+    assert.deepEqual(loadedCommandPreview('/author "testing now" extra', commands), {
+        name: 'author',
+        invocation: '/author "testing now" extra',
+        content: 'Task: testing now extra\nFirst: testing now\nRest: extra\nDefault: none',
+    });
+    assert.equal(loadedCommandPreview('explain /author testing', commands), undefined);
+    assert.equal(loadedCommandPreview('/model', commands), undefined);
+});
+test('deterministic extension preview uses the same raw-argument expansion as /dev submission', () => {
+    const commands = [{
+            name: 'dev',
+            source: 'command',
+            description: 'operate the local stack',
+            expansion: {
+                kind: 'memory-slash',
+                commandName: 'dev',
+                body: 'Interpret `$ARGUMENTS` as the requested stack operation.\nThen act.',
+            },
+        }];
+    assert.deepEqual(loadedCommandPreview('/dev   restart:stack --carefully  ', commands), {
+        name: 'dev',
+        invocation: '/dev   restart:stack --carefully  ',
+        content: 'Interpret `restart:stack --carefully` as the requested stack operation.\nThen act.',
+    });
+});
+test('fresh command metadata replaces a pre-reload expansion before preview recomputes', () => {
+    const before = parsePreviewableCommands(JSON.stringify([{
+            name: 'dev', description: 'operate', source: 'command',
+            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'old $ARGUMENTS' },
+        }]));
+    const after = parsePreviewableCommands(JSON.stringify([{
+            name: 'dev', description: 'operate', source: 'command',
+            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'new $ARGUMENTS' },
+        }]));
+    assert.equal(loadedCommandPreview('/dev restart', before)?.content, 'old restart');
+    assert.equal(loadedCommandPreview('/dev restart', after)?.content, 'new restart');
+});
+test('malformed broker command metadata is discarded without breaking valid inventory', () => {
+    const commands = parsePreviewableCommands(JSON.stringify([
+        { name: 'safe', description: 'safe', source: 'command', expansion: { kind: 'memory-slash', commandName: 'safe', body: 'ok' } },
+        { name: 'bad-kind', description: 'bad', source: 'command', expansion: { kind: 'other', commandName: 'bad-kind', body: 'bad' } },
+        { name: 'bad-body', description: 'bad', source: 'command', expansion: { kind: 'memory-slash', commandName: 'bad-body', body: 3 } },
+        { name: 'bad-template', description: 'bad', source: 'template', template: {} },
+    ]));
+    assert.deepEqual(commands.map((command) => command.name), ['safe']);
+    assert.equal(loadedCommandPreview('/safe', commands)?.content.includes('ok'), true);
+});
+test('submission precedence prevents previews for shadowed templates', () => {
+    const template = { name: 'model', source: 'template', template: 'misleading prompt' };
+    assert.equal(loadedCommandPreview('/model', [
+        { name: 'model', source: 'builtin' },
+        template,
+    ]), undefined, 'viewer builtin wins before template');
+    assert.equal(loadedCommandPreview('/dev now', [
+        { name: 'dev', source: 'command' },
+        { name: 'dev', source: 'template', template: 'also misleading' },
+    ]), undefined, 'non-previewable extension command wins before template');
+});
+test('extension previews use pi ASCII-space matching while templates retain whitespace matching', () => {
+    const commands = [{
+            name: 'dev', source: 'command', description: 'extension',
+            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'extension: $ARGUMENTS' },
+        }, {
+            name: 'dev', source: 'template', description: 'template', template: 'template: $ARGUMENTS',
+        }];
+    assert.equal(loadedCommandPreview('/dev literal space', commands)?.content, 'extension: literal space');
+    assert.equal(loadedCommandPreview('/dev\ttab arg', commands)?.content, 'template: tab arg');
+    assert.equal(loadedCommandPreview('/dev\nnewline arg', commands)?.content, 'template: newline arg');
+});
+test('an empty command inventory clears a loaded preview while fresh metadata is pending', () => {
+    const commands = [{
+            name: 'dev', source: 'command', description: 'extension',
+            expansion: { kind: 'memory-slash', commandName: 'dev', body: 'old $ARGUMENTS' },
+        }];
+    assert.equal(loadedCommandPreview('/dev restart', commands)?.content, 'old restart');
+    assert.equal(loadedCommandPreview('/dev restart', []), undefined);
+});

package/dist/clients/attach/__tests__/ref-autocomplete.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clients/attach/__tests__/ref-autocomplete.test.js

@@ -0,0 +1,176 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { findRefCompletionContext, RefAwareAutocompleteProvider } from '../input/ref-autocomplete.js';
+function ref(name, shortForm = `${name} docs`) {
+    return { name, kind: 'knowledge', scope: 'user', shortForm };
+}
+/** Records every call so delegation (vs. ref handling) is directly assertable. */
+class FakeDelegate {
+    getSuggestionsCalls = [];
+    applyCompletionCalls = [];
+    shouldTriggerFileCompletionCalls = [];
+    suggestions = { items: [{ value: 'reload', label: '/reload' }], prefix: '/' };
+    shouldTrigger = false;
+    async getSuggestions(lines, cursorLine, cursorCol, options) {
+        this.getSuggestionsCalls.push([lines, cursorLine, cursorCol, options]);
+        return this.suggestions;
+    }
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        this.applyCompletionCalls.push([lines, cursorLine, cursorCol, item, prefix]);
+        return { lines, cursorLine, cursorCol };
+    }
+    shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+        this.shouldTriggerFileCompletionCalls.push([lines, cursorLine, cursorCol]);
+        return this.shouldTrigger;
+    }
+}
+const opts = { signal: new AbortController().signal, force: false };
+test('findRefCompletionContext classifies leading, non-leading, and non-token caret positions', () => {
+    // Leading: '/' is the very first character of the whole message.
+    assert.deepEqual(findRefCompletionContext(['/de'], 0, 3), {
+        kind: 'leading',
+        startCol: 0,
+        endCol: 3,
+        prefix: '/de',
+    });
+    // Non-leading: preceded mid-line by whitespace.
+    assert.deepEqual(findRefCompletionContext(['fix /de'], 0, 7), {
+        kind: 'ref',
+        startCol: 4,
+        endCol: 7,
+        prefix: '/de',
+    });
+    // Non-leading: '/' at the start of a LATER logical line — preceding
+    // joined-text character is '\n', not "start of input".
+    assert.deepEqual(findRefCompletionContext(['fix this', '/de'], 1, 3), {
+        kind: 'ref',
+        startCol: 0,
+        endCol: 3,
+        prefix: '/de',
+    });
+    // Bare mid-prose '/' with nothing typed after it yet.
+    assert.deepEqual(findRefCompletionContext(['fix /'], 0, 5), {
+        kind: 'ref',
+        startCol: 4,
+        endCol: 5,
+        prefix: '/',
+    });
+    // Boundary rejection: '/' inside 'http://' is preceded by ':' (non-whitespace).
+    assert.equal(findRefCompletionContext(['see http://example.com'], 0, 12), null);
+    // Boundary rejection: '/' inside 'and/or' is preceded by 'd' (non-whitespace).
+    assert.equal(findRefCompletionContext(['read and/or write'], 0, 10), null);
+    // Caret has moved past the token into trailing whitespace — not touching it.
+    assert.equal(findRefCompletionContext(['/dev  x'], 0, 5), null);
+});
+test('leading /de delegates verbatim and never surfaces refs, even when a matching ref exists', async () => {
+    const delegate = new FakeDelegate();
+    const provider = new RefAwareAutocompleteProvider([ref('dev')], delegate);
+    const result = await provider.getSuggestions(['/de'], 0, 3, opts);
+    assert.equal(result, delegate.suggestions);
+    assert.equal(delegate.getSuggestionsCalls.length, 1);
+    assert.deepEqual(delegate.getSuggestionsCalls[0], [['/de'], 0, 3, opts]);
+});
+test('non-leading /de mid-prose and at the start of a later line surfaces prefix-filtered refs', async () => {
+    const delegate = new FakeDelegate();
+    const refs = [ref('dev', 'dev stack docs'), ref('taste/foo', 'foo taste doc'), ref('other')];
+    const provider = new RefAwareAutocompleteProvider(refs, delegate);
+    const midProse = await provider.getSuggestions(['fix /de'], 0, 7, opts);
+    assert.deepEqual(midProse, {
+        items: [{ value: 'dev', label: '/dev', description: 'dev stack docs' }],
+        prefix: 'de',
+    });
+    assert.equal(delegate.getSuggestionsCalls.length, 0);
+    const laterLine = await provider.getSuggestions(['fix this', '/de'], 1, 3, opts);
+    assert.deepEqual(laterLine, {
+        items: [{ value: 'dev', label: '/dev', description: 'dev stack docs' }],
+        prefix: 'de',
+    });
+    // Bare non-leading '/' offers the whole inventory. The returned `prefix`
+    // strips the leading '/' (review Major 3 — see input/ref-autocomplete.ts) so
+    // pi-tui's `tui.select.confirm` fallthrough never misclassifies a ref
+    // completion as a leading-command completion and submits on Enter.
+    const bare = await provider.getSuggestions(['fix /'], 0, 5, opts);
+    assert.deepEqual(bare, {
+        items: [
+            { value: 'dev', label: '/dev', description: 'dev stack docs' },
+            { value: 'taste/foo', label: '/taste:foo', description: 'foo taste doc' },
+            { value: 'other', label: '/other', description: 'other docs' },
+        ],
+        prefix: '',
+    });
+    // Nested names are offered in colon surface form and filtered by it.
+    const nested = await provider.getSuggestions(['see /tas'], 0, 8, opts);
+    assert.deepEqual(nested, {
+        items: [{ value: 'taste/foo', label: '/taste:foo', description: 'foo taste doc' }],
+        prefix: 'tas',
+    });
+    assert.equal(delegate.getSuggestionsCalls.length, 0, 'no ref-context call ever reaches the wrapped provider');
+});
+test('boundary-invalid strings and no-match prefixes never enter ref mode', async () => {
+    const delegate = new FakeDelegate();
+    const provider = new RefAwareAutocompleteProvider([ref('dev')], delegate);
+    await provider.getSuggestions(['see http://example.com'], 0, 12, opts);
+    await provider.getSuggestions(['read and/or write'], 0, 10, opts);
+    assert.equal(delegate.getSuggestionsCalls.length, 2, 'both boundary cases fell through to the delegate');
+    const noMatch = await provider.getSuggestions(['fix /zz'], 0, 7, opts);
+    assert.equal(noMatch, null, 'a non-leading ref context with no prefix match returns null, not delegate output');
+    assert.equal(delegate.getSuggestionsCalls.length, 2, 'a real (non-matching) ref context still never delegates');
+});
+test('applying a ref completion replaces only the token, adds no separator, and never calls the delegate', () => {
+    const delegate = new FakeDelegate();
+    const provider = new RefAwareAutocompleteProvider([ref('dev')], delegate);
+    const line = 'before /de after';
+    const cursorCol = line.indexOf('/de') + '/de'.length;
+    const item = { value: 'dev', label: '/dev' };
+    const result = provider.applyCompletion([line], 0, cursorCol, item, '/de');
+    assert.deepEqual(result.lines, ['before /dev after']);
+    assert.equal(result.cursorLine, 0);
+    assert.equal(result.cursorCol, 'before /dev'.length);
+    assert.equal(delegate.applyCompletionCalls.length, 0);
+});
+test('applying an item absent from the ref inventory in a real non-leading ref context delegates unchanged', () => {
+    const delegate = new FakeDelegate();
+    const provider = new RefAwareAutocompleteProvider([ref('dev')], delegate);
+    // 'reload' is a command, not a ref — it can never legitimately arrive here,
+    // but the provider must still refuse to treat it as a ref rather than
+    // trusting every slash-valued item blindly.
+    const item = { value: 'reload', label: '/reload' };
+    const result = provider.applyCompletion(['fix /re'], 0, 7, item, '/re');
+    assert.deepEqual(result, { lines: ['fix /re'], cursorLine: 0, cursorCol: 7 });
+    assert.equal(delegate.applyCompletionCalls.length, 1);
+    assert.deepEqual(delegate.applyCompletionCalls[0], [['fix /re'], 0, 7, item, '/re']);
+});
+test('applying at a leading-command position always delegates, regardless of item.value', () => {
+    const delegate = new FakeDelegate();
+    const provider = new RefAwareAutocompleteProvider([ref('re')], delegate);
+    const item = { value: 're', label: '/re' };
+    const result = provider.applyCompletion(['/re'], 0, 3, item, '/re');
+    assert.deepEqual(result, { lines: ['/re'], cursorLine: 0, cursorCol: 3 });
+    assert.equal(delegate.applyCompletionCalls.length, 1);
+    assert.deepEqual(delegate.applyCompletionCalls[0], [['/re'], 0, 3, item, '/re']);
+});
+test('shouldTriggerFileCompletion is forced true only in a non-leading ref context', () => {
+    const delegate = new FakeDelegate();
+    const provider = new RefAwareAutocompleteProvider([ref('dev')], delegate);
+    assert.equal(provider.shouldTriggerFileCompletion(['before /de after'], 0, 'before /de'.length), true);
+    assert.equal(delegate.shouldTriggerFileCompletionCalls.length, 0);
+    // Leading context delegates.
+    delegate.shouldTrigger = true;
+    assert.equal(provider.shouldTriggerFileCompletion(['/de'], 0, 3), true);
+    assert.equal(delegate.shouldTriggerFileCompletionCalls.length, 1);
+    // Non-token context (e.g. an '@' file-mention position) delegates too.
+    delegate.shouldTrigger = false;
+    const line = 'see @file.txt';
+    assert.equal(provider.shouldTriggerFileCompletion([line], 0, line.length), false);
+    assert.equal(delegate.shouldTriggerFileCompletionCalls.length, 2);
+});
+test('triggerCharacters passes through the wrapped provider unchanged', () => {
+    class DelegateWithTrigger extends FakeDelegate {
+        triggerCharacters = ['@'];
+    }
+    const delegate = new DelegateWithTrigger();
+    const provider = new RefAwareAutocompleteProvider([ref('dev')], delegate);
+    assert.deepEqual(provider.triggerCharacters, ['@']);
+    const bare = new RefAwareAutocompleteProvider([ref('dev')], new FakeDelegate());
+    assert.equal(bare.triggerCharacters, undefined);
+});

package/dist/clients/attach/__tests__/titled-editor-preview.test.d.ts

@@ -0,0 +1 @@
+export {};