@nimbalyst/extension-sdk 0.2.2 → 0.4.0

package/CHANGELOG.md

@@ -8,6 +8,8 @@ The SDK is versioned independently of the Nimbalyst app. Each release declares i
 
 | SDK version | Minimum Nimbalyst app version |
 | --- | --- |
+| 0.4.0 | 0.70.0 |
+| 0.3.0 | 0.70.0 |
 | 0.2.2 | 0.58.5 |
 | 0.2.1 | 0.58.5 |
 | 0.2.0 | 0.58.5 |
@@ -16,6 +18,26 @@ The SDK is versioned independently of the Nimbalyst app. Each release declares i
 
 ## [Unreleased]
 
+## [0.4.0]
+
+### Added
+
+- `applyTextDiff()` and `replaceYText()` reduce a whole-string replacement to one contiguous `Y.Text` edit, so a binding no longer has to hand-write the prefix/suffix diff.
+- `@nimbalyst/extension-sdk/collab` is a React-free entry point for the collaborative-document helpers, for codecs and codec tests that have no React installed.
+- `host.onFindRequested()` routes the app's Find command (Cmd+F) to a custom editor's own find UI.
+
+## [0.3.0]
+
+Requires Nimbalyst 0.70.0 for the new host-provided selection, filesystem, and visibility APIs.
+
+### Added
+
+- `host.setEditorContextItems()` and `EditorContextItem` let node-like editors (diagrams, CAD, electronics) push a list of selected items to the chat as individually removable context chips, instead of a single `setEditorContext` blob.
+- `host.fs` (`EditorHostFileSystem`) reads files with SHA-256 version tokens and applies labeled, compare-and-swap grouped writes recorded in document history.
+- `host.openExternal()` opens a reviewed HTTPS URL in the operating system's browser without navigating the renderer.
+- `host.visible` and `host.onVisibilityChanged()` let editors pause render loops and release GPU resources while mounted but hidden.
+- `ExtensionFileSystemService.writeFile()` accepts a `Uint8Array` so extensions can write binary files without corrupting their contents.
+
 ## [0.2.2]
 
 ### Added

package/dist/__tests__/buildEmitStability.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buildEmitStability.test.d.ts.map

package/dist/__tests__/buildEmitStability.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildEmitStability.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/buildEmitStability.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/buildEmitStability.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+/**
+ * The renderer resolves `@nimbalyst/extension-sdk` to `dist/`, so every file the
+ * SDK build emits lives in the dev server's module graph. When the build wiped
+ * dist and re-emitted all 114 files, the pre-push gate (`typecheck:prepush`,
+ * which builds the SDK on every push) made Vite full-reload every open Electron
+ * window -- several times an hour across parallel agent sessions, with no SDK
+ * source change involved. These assertions keep the emit stable.
+ */
+const sdkRoot = resolve(__dirname, '../..');
+function readJsonc(relativePath) {
+    const text = readFileSync(resolve(sdkRoot, relativePath), 'utf8');
+    return JSON.parse(text.replace(/^\s*\/\/.*$/gm, ''));
+}
+describe('extension-sdk build emit stability', () => {
+    it('does not wipe dist on the default build', () => {
+        const { scripts } = readJsonc('package.json');
+        expect(scripts.build).toBe('tsc');
+        expect(scripts.build).not.toMatch(/rmSync|rm -rf/);
+    });
+    it('emits incrementally so unchanged sources produce no file writes', () => {
+        const { compilerOptions } = readJsonc('tsconfig.json');
+        expect(compilerOptions.incremental).toBe(true);
+        expect(compilerOptions.tsBuildInfoFile).toBeTruthy();
+    });
+    it('keeps a clean build available for publishing', () => {
+        const { scripts } = readJsonc('package.json');
+        expect(scripts['build:clean']).toMatch(/rmSync/);
+        expect(scripts.prepublishOnly).toBe('npm run build:clean');
+    });
+});

package/dist/__tests__/createTextCollabContentAdapter.test.js

@@ -1,3 +1,4 @@
+// @vitest-environment node
 import { describe, expect, it } from 'vitest';
 import * as Y from 'yjs';
 import { createTextCollabContentAdapter } from '../collab/createTextCollabContentAdapter';

package/dist/__tests__/externalsPlugin.test.js

@@ -13,4 +13,54 @@ describe('nimbalystExternalsPlugin runtime bridge', () => {
         expect(source).toContain('export const useResolvedTrackerReference');
         expect(source).toContain('export const navigateToTrackerReference');
     });
+    it('evaluates the react-dom bridge against the React 19 host export shape', async () => {
+        const plugin = nimbalystExternalsPlugin();
+        const resolveId = plugin.resolveId;
+        const load = plugin.load;
+        const id = await resolveId('react-dom', undefined, {});
+        expect(id).toBe('\0nimbalyst-external:react-dom');
+        const source = await load(id);
+        expect(typeof source).toBe('string');
+        expect(source).not.toContain('export const render');
+        expect(source).not.toContain('export const hydrate');
+        expect(source).not.toContain('export const findDOMNode');
+        expect(source).not.toContain('export const unmountComponentAtNode');
+        const createPortal = () => null;
+        const preload = () => undefined;
+        const hostReactDOM = {
+            createPortal,
+            flushSync: () => undefined,
+            preload,
+            version: '19.2.7',
+        };
+        const executableSource = String(source)
+            .replace('export default __nimbalyst_mod__;', 'const __default__ = __nimbalyst_mod__;')
+            .replace(/export const (\w+) =/g, 'const $1 =');
+        const evaluate = new Function('window', `${executableSource}
+      return {
+        default: __default__, createPortal, preload, preconnect, version,
+        render: typeof render === 'undefined' ? undefined : render,
+        hydrate: typeof hydrate === 'undefined' ? undefined : hydrate,
+        findDOMNode: typeof findDOMNode === 'undefined' ? undefined : findDOMNode,
+        unmountComponentAtNode: typeof unmountComponentAtNode === 'undefined'
+          ? undefined
+          : unmountComponentAtNode,
+      };`);
+        const evaluated = evaluate({
+            __nimbalyst_extensions: {
+                'react-dom': hostReactDOM,
+            },
+        });
+        expect(evaluated).toBeTypeOf('object');
+        const exports = evaluated;
+        expect(exports.default).toBe(hostReactDOM);
+        expect(exports.createPortal).toBe(createPortal);
+        expect(exports.preload).toBe(preload);
+        expect(exports.preconnect).toBeUndefined();
+        expect(exports.version).toBe('19.2.7');
+        expect(exports.render).toBeUndefined();
+        expect(exports.hydrate).toBeUndefined();
+        expect(exports.findDOMNode).toBeUndefined();
+        expect(exports.unmountComponentAtNode).toBeUndefined();
+    });
 });

package/dist/__tests__/fileDirectoryTree.test.js

@@ -1,3 +1,4 @@
+// @vitest-environment node
 import { describe, expect, it } from 'vitest';
 import { buildFileDirectoryTree, getFileDirectoryPaths, getFilePathBasename, getWorkspaceRelativeFilePath, } from '../fileDirectoryTree';
 const buildTree = (files, workspacePath) => buildFileDirectoryTree(files.map(filePath => ({ filePath })), file => file.filePath, workspacePath);
@@ -21,6 +22,10 @@ describe('file path helpers', () => {
         expect(getFilePathBasename('packages/runtime/index.ts')).toBe('index.ts');
         expect(getFilePathBasename('packages\\runtime\\index.ts')).toBe('index.ts');
     });
+    it('gets directory names from paths with trailing separators', () => {
+        expect(getFilePathBasename('docs/')).toBe('docs');
+        expect(getFilePathBasename('packages\\runtime\\')).toBe('runtime');
+    });
 });
 describe('buildFileDirectoryTree', () => {
     it('groups Windows files with duplicate basenames under their directories', () => {

package/dist/__tests__/fileMask.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fileMask.test.d.ts.map

package/dist/__tests__/fileMask.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileMask.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/fileMask.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/fileMask.test.js

@@ -0,0 +1,33 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest';
+import { parseFileMask, matchesFileMask } from '../fileMask';
+describe('fileMask', () => {
+    it('matches a name glob against Windows back-slashed paths', () => {
+        // #1196: main returns `path.normalize`d paths, so on Windows the mask sees
+        // `C:\...\Ch01.md`. Before the separator normalization only `*.md` matched
+        // (the whole path has no `/`), which read as "the mask filters by
+        // extension only".
+        const winPath = 'C:\\Users\\me\\book\\Ch01.md';
+        expect(matchesFileMask(winPath, parseFileMask('Ch0*.md'))).toBe(true);
+        expect(matchesFileMask(winPath, parseFileMask('*.md'))).toBe(true);
+        expect(matchesFileMask(winPath, parseFileMask('Notes*.md'))).toBe(false);
+        expect(matchesFileMask('C:\\Users\\me\\book\\notes.txt', parseFileMask('Ch0*.md'))).toBe(false);
+    });
+    it('matches names, directory globs and comma-separated lists on posix paths', () => {
+        const patterns = parseFileMask('Ch0*.md, *.ts');
+        expect(matchesFileMask('/Users/me/book/Ch01.md', patterns)).toBe(true);
+        expect(matchesFileMask('/Users/me/book/index.ts', patterns)).toBe(true);
+        expect(matchesFileMask('/Users/me/book/index.tsx', patterns)).toBe(false);
+        // `*` stops at a separator, `**` crosses them, `?` is a single character.
+        expect(matchesFileMask('src/a/b.test.ts', parseFileMask('src/*.test.ts'))).toBe(false);
+        expect(matchesFileMask('src/a/b.test.ts', parseFileMask('src/**/*.test.ts'))).toBe(true);
+        expect(matchesFileMask('src\\a\\b.test.ts', parseFileMask('src/**/*.test.ts'))).toBe(true);
+        expect(matchesFileMask('Ch1.md', parseFileMask('Ch?.md'))).toBe(true);
+        expect(matchesFileMask('Ch12.md', parseFileMask('Ch?.md'))).toBe(false);
+    });
+    it('treats an empty or absent mask as no filter', () => {
+        expect(parseFileMask(undefined)).toEqual([]);
+        expect(parseFileMask('  ,  ')).toEqual([]);
+        expect(matchesFileMask('anything.bin', [])).toBe(true);
+    });
+});

package/dist/__tests__/manifestValidation.agentProviders.test.js

@@ -1,3 +1,4 @@
+// @vitest-environment node
 import { describe, it, expect } from 'vitest';
 import { validateAgentProviders } from '../manifestValidation';
 // The validator must agree with the AiAgentProviderContribution /

package/dist/__tests__/textReplacement.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=textReplacement.test.d.ts.map

package/dist/__tests__/textReplacement.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textReplacement.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/textReplacement.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/textReplacement.test.js

@@ -0,0 +1,31 @@
+// @vitest-environment node
+import { describe, expect, it, vi } from 'vitest';
+import * as Y from 'yjs';
+import { applyTextDiff, replaceYText } from '../collab/textReplacement';
+describe('text replacement', () => {
+    it('reduces whole-string replacements to one range edit', () => {
+        const cases = [
+            { name: 'insert-only', previous: 'abcd', next: 'abXcd', edit: [2, 2, 'X'] },
+            { name: 'delete-only', previous: 'abcd', next: 'acd', edit: [1, 2, ''] },
+            { name: 'replace-in-the-middle', previous: 'abcde', next: 'abXYde', edit: [2, 3, 'XY'] },
+            { name: 'identical', previous: 'same', next: 'same', edit: null },
+            { name: 'empty-to-nonempty', previous: '', next: 'new', edit: [0, 0, 'new'] },
+        ];
+        for (const { name, previous, next, edit } of cases) {
+            const applyEdit = vi.fn();
+            applyTextDiff(previous, next, applyEdit);
+            if (edit === null) {
+                expect(applyEdit, name).not.toHaveBeenCalled();
+            }
+            else {
+                expect(applyEdit, name).toHaveBeenCalledOnce();
+                expect(applyEdit, name).toHaveBeenCalledWith(...edit);
+            }
+            const yText = new Y.Text(previous);
+            const doc = new Y.Doc();
+            doc.getMap('root').set('text', yText);
+            replaceYText(yText, next);
+            expect(yText.toString(), name).toBe(next);
+        }
+    });
+});

package/dist/__tests__/useCollaborativeEditor.offline.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useCollaborativeEditor.offline.test.d.ts.map

package/dist/__tests__/useCollaborativeEditor.offline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCollaborativeEditor.offline.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/useCollaborativeEditor.offline.test.tsx"],"names":[],"mappings":""}

package/dist/__tests__/useCollaborativeEditor.offline.test.js

@@ -0,0 +1,34 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { Awareness } from 'y-protocols/awareness';
+import { describe, expect, it, vi } from 'vitest';
+import * as Y from 'yjs';
+import { useCollaborativeEditor } from '../useCollaborativeEditor.js';
+describe('useCollaborativeEditor offline replica binding', () => {
+    it('binds an already-hydrated Y.Doc without waiting for the transport', async () => {
+        const yDoc = new Y.Doc();
+        yDoc.getMap('nodes').set('node_root', 'persisted');
+        const awareness = new Awareness(yDoc);
+        const loadInitialContent = vi.fn(async () => 'must not seed offline');
+        const bind = vi.fn(() => ({ destroy: vi.fn() }));
+        const host = {
+            collaboration: {
+                yDoc,
+                awareness,
+                user: { id: 'offline-user', name: 'Offline User', color: '#123456' },
+                getStatus: () => 'disconnected',
+                onStatusChange: () => () => { },
+                loadInitialContent,
+            },
+        };
+        const { unmount } = renderHook(() => useCollaborativeEditor(host, {
+            isEmpty: doc => doc.getMap('nodes').size === 0,
+            initializeFromContent: vi.fn(),
+            createBinding: bind,
+        }));
+        await waitFor(() => expect(bind).toHaveBeenCalledTimes(1));
+        expect(loadInitialContent).not.toHaveBeenCalled();
+        unmount();
+        awareness.destroy();
+        yDoc.destroy();
+    });
+});

package/dist/__tests__/useEditorLifecycle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useEditorLifecycle.test.d.ts.map

package/dist/__tests__/useEditorLifecycle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorLifecycle.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/useEditorLifecycle.test.tsx"],"names":[],"mappings":""}

package/dist/__tests__/useEditorLifecycle.test.js

@@ -0,0 +1,60 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import { useEditorLifecycle } from '../useEditorLifecycle.js';
+function createHost(loadContent) {
+    let fileChanged;
+    const host = {
+        filePath: '/workspace/plans/example.mockup.html',
+        fileName: 'example.mockup.html',
+        isActive: true,
+        theme: 'dark',
+        loadContent,
+        loadBinaryContent: vi.fn(),
+        saveContent: vi.fn(),
+        setDirty: vi.fn(),
+        onSaveRequested: () => () => { },
+        onFileChanged: (callback) => {
+            fileChanged = callback;
+            return () => {
+                fileChanged = undefined;
+            };
+        },
+        onThemeChanged: () => () => { },
+        registerMenuItems: vi.fn(),
+        registerEditorAPI: vi.fn(),
+        setEditorContext: vi.fn(),
+        setEditorContextItems: vi.fn(),
+        storage: {
+            get: vi.fn(),
+            set: vi.fn(),
+            delete: vi.fn(),
+            getGlobal: vi.fn(),
+            setGlobal: vi.fn(),
+            deleteGlobal: vi.fn(),
+            getSecret: vi.fn(),
+            setSecret: vi.fn(),
+            deleteSecret: vi.fn(),
+        },
+    };
+    return {
+        host,
+        notifyFileChanged(content) {
+            fileChanged?.(content);
+        },
+    };
+}
+describe('useEditorLifecycle', () => {
+    it('recovers when a missing file appears after the initial load fails', async () => {
+        const applyContent = vi.fn();
+        const { host, notifyFileChanged } = createHost(() => Promise.reject(new Error('File not found')));
+        const { result } = renderHook(() => useEditorLifecycle(host, { applyContent }));
+        await waitFor(() => {
+            expect(result.current.error?.message).toBe('File not found');
+        });
+        act(() => {
+            notifyFileChanged('<html>created later</html>');
+        });
+        expect(applyContent).toHaveBeenCalledWith('<html>created later</html>');
+        expect(result.current.error).toBeNull();
+    });
+});

package/dist/collab/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * React-free public entry for the collaborative-document helpers.
+ *
+ * The package root re-exports everything here, but the root barrel also pulls
+ * in `useEditorLifecycle` and therefore `react` — a peer dependency the host
+ * injects at runtime. A codec or a codec test that only touches `Y.Doc` has no
+ * React installed, so importing the root barrel fails to resolve for it.
+ * `@nimbalyst/extension-sdk/collab` is the entry those consumers import
+ * instead, so nobody has to reach into `dist/` by path.
+ */
+export { COLLAB_INIT_ORIGIN } from './origins.js';
+export { createTextCollabContentAdapter, reconstructCollabContentAdapterFromDescriptor, TEXT_COLLAB_DEFAULT_FIELD, type TextCollabContentAdapterOptions, } from './createTextCollabContentAdapter.js';
+export { applyTextDiff, replaceYText, type ApplyTextEdit, } from './textReplacement.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/collab/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collab/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,EACL,8BAA8B,EAC9B,6CAA6C,EAC7C,yBAAyB,EACzB,KAAK,+BAA+B,GACrC,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,aAAa,EACb,YAAY,EACZ,KAAK,aAAa,GACnB,MAAM,sBAAsB,CAAC"}

package/dist/collab/index.js

@@ -0,0 +1,13 @@
+/**
+ * React-free public entry for the collaborative-document helpers.
+ *
+ * The package root re-exports everything here, but the root barrel also pulls
+ * in `useEditorLifecycle` and therefore `react` — a peer dependency the host
+ * injects at runtime. A codec or a codec test that only touches `Y.Doc` has no
+ * React installed, so importing the root barrel fails to resolve for it.
+ * `@nimbalyst/extension-sdk/collab` is the entry those consumers import
+ * instead, so nobody has to reach into `dist/` by path.
+ */
+export { COLLAB_INIT_ORIGIN } from './origins.js';
+export { createTextCollabContentAdapter, reconstructCollabContentAdapterFromDescriptor, TEXT_COLLAB_DEFAULT_FIELD, } from './createTextCollabContentAdapter.js';
+export { applyTextDiff, replaceYText, } from './textReplacement.js';

package/dist/collab/origins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Origin tag used when the SDK wraps `initializeFromContent` in a Y.Doc
+ * transaction. Extension bindings can compare a transaction's origin
+ * against this to suppress their own change handlers during seeding
+ * (otherwise the binding would echo the seed back into local-edit state).
+ *
+ * ```ts
+ * yDoc.on('update', (update, origin) => {
+ *   if (origin === COLLAB_INIT_ORIGIN) return;
+ *   // ... apply remote change
+ * });
+ * ```
+ */
+export declare const COLLAB_INIT_ORIGIN: unique symbol;
+//# sourceMappingURL=origins.d.ts.map

package/dist/collab/origins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origins.d.ts","sourceRoot":"","sources":["../../src/collab/origins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,eAAkC,CAAC"}

package/dist/collab/origins.js

@@ -0,0 +1,14 @@
+/**
+ * Origin tag used when the SDK wraps `initializeFromContent` in a Y.Doc
+ * transaction. Extension bindings can compare a transaction's origin
+ * against this to suppress their own change handlers during seeding
+ * (otherwise the binding would echo the seed back into local-edit state).
+ *
+ * ```ts
+ * yDoc.on('update', (update, origin) => {
+ *   if (origin === COLLAB_INIT_ORIGIN) return;
+ *   // ... apply remote change
+ * });
+ * ```
+ */
+export const COLLAB_INIT_ORIGIN = Symbol('nimbalyst:collab-init');

package/dist/collab/textReplacement.d.ts

@@ -0,0 +1,7 @@
+import type * as Y from 'yjs';
+export type ApplyTextEdit = (start: number, end: number, inserted: string) => void;
+/** Reduce a whole-string replacement to one contiguous range edit. */
+export declare function applyTextDiff(previous: string, next: string, applyEdit: ApplyTextEdit): void;
+/** Apply a whole-string replacement to a Y.Text as one contiguous edit. */
+export declare function replaceYText(target: Y.Text, next: string): void;
+//# sourceMappingURL=textReplacement.d.ts.map

package/dist/collab/textReplacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textReplacement.d.ts","sourceRoot":"","sources":["../../src/collab/textReplacement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAC;AAE9B,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;AAEnF,sEAAsE;AACtE,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,aAAa,GACvB,IAAI,CAmBN;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAM/D"}

package/dist/collab/textReplacement.js

@@ -0,0 +1,27 @@
+/** Reduce a whole-string replacement to one contiguous range edit. */
+export function applyTextDiff(previous, next, applyEdit) {
+    if (previous === next)
+        return;
+    let prefix = 0;
+    const prefixLimit = Math.min(previous.length, next.length);
+    while (prefix < prefixLimit && previous.charCodeAt(prefix) === next.charCodeAt(prefix)) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    const suffixLimit = Math.min(previous.length - prefix, next.length - prefix);
+    while (suffix < suffixLimit
+        && previous.charCodeAt(previous.length - 1 - suffix) === next.charCodeAt(next.length - 1 - suffix)) {
+        suffix += 1;
+    }
+    applyEdit(prefix, previous.length - suffix, next.slice(prefix, next.length - suffix));
+}
+/** Apply a whole-string replacement to a Y.Text as one contiguous edit. */
+export function replaceYText(target, next) {
+    applyTextDiff(target.toString(), next, (start, end, inserted) => {
+        const removeLength = end - start;
+        if (removeLength > 0)
+            target.delete(start, removeLength);
+        if (inserted.length > 0)
+            target.insert(start, inserted);
+    });
+}

package/dist/createReadOnlyHost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createReadOnlyHost.d.ts","sourceRoot":"","sources":["../src/createReadOnlyHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAiC,MAAM,mBAAmB,CAAC;AAEnF,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IAEd,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,GACxB,YAAY,CA6Dd"}
+{"version":3,"file":"createReadOnlyHost.d.ts","sourceRoot":"","sources":["../src/createReadOnlyHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAiC,MAAM,mBAAmB,CAAC;AAEnF,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IAEd,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,GACxB,YAAY,CA8Dd"}

package/dist/createReadOnlyHost.js

@@ -61,6 +61,7 @@ export function createReadOnlyHost(content, opts) {
         registerMenuItems: (_items) => { },
         registerEditorAPI: () => { },
         setEditorContext: (_context) => { },
+        setEditorContextItems: () => { },
         // -- Storage (in-memory, non-persistent) --
         storage: {
             get: (_key) => undefined,

package/dist/electronMain.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Narrow Extension SDK entry used by the Electron main-process bundle.
+ *
+ * The public SDK barrel includes renderer hooks and components. Main-process
+ * code only needs manifest validation, tracker-importer constants, and the
+ * serializable collaboration adapter factory.
+ */
+export { effectiveModulePermissions, validateBackendModules, } from './manifestValidation';
+export { TRACKER_IMPORTER_RPC_METHODS } from './types/trackerImporter';
+export { createTextCollabContentAdapter, reconstructCollabContentAdapterFromDescriptor, } from './collab/createTextCollabContentAdapter';
+export { COLLAB_INIT_ORIGIN } from './collab/origins';
+//# sourceMappingURL=electronMain.d.ts.map

package/dist/electronMain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"electronMain.d.ts","sourceRoot":"","sources":["../src/electronMain.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EACL,8BAA8B,EAC9B,6CAA6C,GAC9C,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/electronMain.js

@@ -0,0 +1,11 @@
+/**
+ * Narrow Extension SDK entry used by the Electron main-process bundle.
+ *
+ * The public SDK barrel includes renderer hooks and components. Main-process
+ * code only needs manifest validation, tracker-importer constants, and the
+ * serializable collaboration adapter factory.
+ */
+export { effectiveModulePermissions, validateBackendModules, } from './manifestValidation';
+export { TRACKER_IMPORTER_RPC_METHODS } from './types/trackerImporter';
+export { createTextCollabContentAdapter, reconstructCollabContentAdapterFromDescriptor, } from './collab/createTextCollabContentAdapter';
+export { COLLAB_INIT_ORIGIN } from './collab/origins';

package/dist/externalsPlugin.js

@@ -149,12 +149,16 @@ function generateCommonExports(externalKey) {
             'version', 'useInsertionEffect', 'cache', 'use', 'act',
         ];
     }
-    else if (externalKey === 'react-dom' || externalKey === 'react-dom/client') {
+    else if (externalKey === 'react-dom') {
         exports = [
-            'createRoot', 'hydrateRoot', 'render', 'hydrate', 'createPortal', 'flushSync',
-            'unmountComponentAtNode', 'findDOMNode', 'unstable_batchedUpdates',
+            'createPortal', 'flushSync', 'preconnect', 'prefetchDNS', 'preinit',
+            'preinitModule', 'preload', 'preloadModule', 'requestFormReset',
+            'unstable_batchedUpdates', 'useFormState', 'useFormStatus', 'version',
         ];
     }
+    else if (externalKey === 'react-dom/client') {
+        exports = ['createRoot', 'hydrateRoot', 'version'];
+    }
     else if (externalKey === 'react/jsx-runtime' || externalKey === 'react/jsx-dev-runtime') {
         exports = ['jsx', 'jsxs', 'jsxDEV', 'Fragment'];
     }

package/dist/fileDirectoryTree.js

@@ -3,7 +3,7 @@ export function normalizeFilePath(filePath) {
     return filePath.replace(/[\\/]+/g, '/');
 }
 export function getFilePathBasename(filePath) {
-    const normalizedPath = normalizeFilePath(filePath);
+    const normalizedPath = normalizeFilePath(filePath).replace(/\/+$/, '');
     return normalizedPath.slice(normalizedPath.lastIndexOf('/') + 1);
 }
 /**

package/dist/fileMask.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Comma-separated file mask matching, shared by Quick Open (renderer and main)
+ * and the git extension's Changes filter so the syntax means the same thing
+ * everywhere:
+ *
+ *   "*.ts,*.tsx"        — any .ts or .tsx file
+ *   "src/** /*.test.ts" — recursive pattern
+ *   "Ch0*.md"           — case-insensitive filename match
+ *
+ * Glob semantics: `*` matches any run of non-slash characters, `**` matches
+ * anything (across slashes), `?` matches a single non-slash character. The
+ * pattern is matched against both the basename and the full path so users can
+ * write either `*.ts` or `src/*.ts` and get what they expect.
+ */
+export declare function parseFileMask(mask: string | null | undefined): RegExp[];
+export declare function matchesFileMask(filePath: string, patterns: RegExp[]): boolean;
+//# sourceMappingURL=fileMask.d.ts.map

package/dist/fileMask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileMask.d.ts","sourceRoot":"","sources":["../src/fileMask.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAcH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAOvE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAS7E"}

package/dist/fileMask.js

@@ -0,0 +1,45 @@
+/**
+ * Comma-separated file mask matching, shared by Quick Open (renderer and main)
+ * and the git extension's Changes filter so the syntax means the same thing
+ * everywhere:
+ *
+ *   "*.ts,*.tsx"        — any .ts or .tsx file
+ *   "src/** /*.test.ts" — recursive pattern
+ *   "Ch0*.md"           — case-insensitive filename match
+ *
+ * Glob semantics: `*` matches any run of non-slash characters, `**` matches
+ * anything (across slashes), `?` matches a single non-slash character. The
+ * pattern is matched against both the basename and the full path so users can
+ * write either `*.ts` or `src/*.ts` and get what they expect.
+ */
+function globToRegex(glob) {
+    // Escape regex special chars except * and ?
+    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    // Convert glob wildcards: ** -> match any path, * -> match any non-slash, ? -> single non-slash
+    const pattern = escaped
+        .replace(/\*\*/g, '__DOUBLESTAR__')
+        .replace(/\*/g, '[^/]*')
+        .replace(/__DOUBLESTAR__/g, '.*')
+        .replace(/\?/g, '[^/]');
+    return new RegExp(`^${pattern}$`, 'i');
+}
+export function parseFileMask(mask) {
+    if (!mask)
+        return [];
+    return mask
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map(globToRegex);
+}
+export function matchesFileMask(filePath, patterns) {
+    if (patterns.length === 0)
+        return true;
+    // Windows paths arrive back-slashed (main runs `path.normalize`). Without
+    // this the basename split finds no separator, so the whole absolute path is
+    // treated as the filename: `*.md` still matches it but `Ch0*.md` never can,
+    // which is the extension-only filtering reported in #1196.
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const basename = normalizedPath.split('/').pop() ?? normalizedPath;
+    return patterns.some((re) => re.test(basename) || re.test(normalizedPath));
+}

package/dist/index.d.ts

@@ -27,6 +27,7 @@ export * from './types/index.js';
 export { useEditorLifecycle, type UseEditorLifecycleOptions, type UseEditorLifecycleResult, type DiffState, } from './useEditorLifecycle.js';
 export { useCollaborativeEditor, COLLAB_INIT_ORIGIN, type UseCollaborativeEditorConfig, type UseCollaborativeEditorResult, } from './useCollaborativeEditor.js';
 export { createTextCollabContentAdapter, reconstructCollabContentAdapterFromDescriptor, TEXT_COLLAB_DEFAULT_FIELD, type TextCollabContentAdapterOptions, } from './collab/createTextCollabContentAdapter.js';
+export { applyTextDiff, replaceYText, type ApplyTextEdit, } from './collab/textReplacement.js';
 export { useDocumentPath, type DocumentPathContextValue, } from './documentPath.js';
 export { MaterialSymbol } from './MaterialSymbol.js';
 export { TrackerReferenceChip, TrackerReferencePicker, navigateToTrackerReference, useResolvedTrackerReference, type ResolvedTrackerReference, type TrackerReferenceChipProps, type TrackerReferencePickerProps, } from './trackerReferences.js';