@nimbalyst/extension-sdk 0.1.5 → 0.2.1

package/dist/agents/AgentProtocolHost.js

@@ -0,0 +1,42 @@
+/**
+ * AgentProtocolHost
+ * -----------------
+ *
+ * Surface that the host (Nimbalyst) provides to an extension-owned
+ * `AgentProtocol` implementation at runtime. The protocol implementation
+ * lives in an extension's backend module and is brokered to the host by
+ * the privileged-host backend-module runtime; it must never reach for
+ * host internals directly.
+ *
+ * Identity fields are immutable for the lifetime of the host: they
+ * identify which extension contribution this protocol instance belongs
+ * to and which backend module is hosting it. Per-turn inputs (session
+ * id, workspace path, model, abort signal, permission mode, MCP
+ * servers, environment) are immutable for the lifetime of a single
+ * turn but may differ between turns on the same host instance.
+ *
+ * All async methods reject when the underlying broker call is rejected
+ * by the host (missing permission, unknown session, workspace
+ * mismatch, etc.) -- the protocol implementation is expected to
+ * surface those rejections as protocol-level errors rather than
+ * swallowing them.
+ *
+ * -------------------------------------------------------------------
+ * Q7 -- scope of this host (Phase-4 SDK proposal, resolved 2026-06-02)
+ * -------------------------------------------------------------------
+ *
+ * Per Q7 (Phase-4 SDK proposal, resolved 2026-06-02):
+ * emitEvent / requestPermission / askUserQuestion stay provider-private
+ * per the established upstream pattern (OpenAICodexProvider:1422-1491,
+ * claudeCode/askUserQuestion.ts:10, ProviderSessionManager.ts:49).
+ * Section 4.3's full facade is the agreed end-state, hoisted
+ * incrementally when each in-tree provider is next touched. Phase 4
+ * therefore ships the minimal 5-method host below; the missing
+ * methods are NOT a regression -- they live on the provider's own
+ * surface today and migrate behind a stable facade as each provider
+ * is reworked.
+ *
+ * See `docs/EXTENSION_ARCHITECTURE.md` and the Phase 4 SDK design doc
+ * (Section 4.3) for the full host contract.
+ */
+export {};

package/dist/agents/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Public agent-provider surface for the Nimbalyst extension SDK.
+ *
+ * Extensions that ship an `AiAgentProviderContribution` import the
+ * `AgentProtocol`, `AgentProtocolHost`, and supporting types from
+ * this subpath:
+ *
+ *     import type {
+ *       AgentProtocol,
+ *       AgentProtocolHost,
+ *       PermissionMode,
+ *     } from '@nimbalyst/extension-sdk/agents';
+ *
+ * Ownership model (post Phase-4 dependency inversion):
+ *
+ *   - The transport types (`AgentProtocol`, `ProtocolEvent`, ...) are
+ *     owned by the SDK in `./AgentProtocol`. The runtime re-exports
+ *     them from its own `ProtocolInterface` module so existing
+ *     runtime imports stay source-stable.
+ *   - The host-surface types (`AgentProtocolHost`, `PermissionMode`,
+ *     `McpToolDefinition`) live in this package because they only
+ *     have meaning at the extension boundary.
+ */
+export type { AgentProtocol, ProtocolEvent, ProtocolMessage, ProtocolSession, ProtocolAttachment, SessionOptions, ProtocolEventType, ToolResult, MCPServerConfig, RawProtocolSession, } from './AgentProtocol.js';
+export type { AgentProtocolHost, PermissionMode, McpToolDefinition, } from './AgentProtocolHost.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,YAAY,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,eAAe,EACf,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAc5B,YAAY,EACV,iBAAiB,EACjB,cAAc,EACd,iBAAiB,GAClB,MAAM,wBAAwB,CAAC"}

package/dist/agents/index.js

@@ -0,0 +1,24 @@
+/**
+ * Public agent-provider surface for the Nimbalyst extension SDK.
+ *
+ * Extensions that ship an `AiAgentProviderContribution` import the
+ * `AgentProtocol`, `AgentProtocolHost`, and supporting types from
+ * this subpath:
+ *
+ *     import type {
+ *       AgentProtocol,
+ *       AgentProtocolHost,
+ *       PermissionMode,
+ *     } from '@nimbalyst/extension-sdk/agents';
+ *
+ * Ownership model (post Phase-4 dependency inversion):
+ *
+ *   - The transport types (`AgentProtocol`, `ProtocolEvent`, ...) are
+ *     owned by the SDK in `./AgentProtocol`. The runtime re-exports
+ *     them from its own `ProtocolInterface` module so existing
+ *     runtime imports stay source-stable.
+ *   - The host-surface types (`AgentProtocolHost`, `PermissionMode`,
+ *     `McpToolDefinition`) live in this package because they only
+ *     have meaning at the extension boundary.
+ */
+export {};

package/dist/collab/createTextCollabContentAdapter.d.ts

@@ -0,0 +1,26 @@
+import type { CollabAdapterDescriptor, CollabContentAdapter } from '../types/collab.js';
+/** Default `Y.Text` field name used when none is supplied. */
+export declare const TEXT_COLLAB_DEFAULT_FIELD = "content";
+export interface TextCollabContentAdapterOptions {
+    /** Logical document type. Matches the shared doc's documentType and, by
+     *  convention, the custom-editor suffix without its dot (e.g. 'calc.md'). */
+    documentType: string;
+    /** On-disk extensions this adapter is the codec for (leading dot). The
+     *  first entry is the default for save-a-copy / export. */
+    fileExtensions: string[];
+    /** Optional MIME type for save dialogs / asset uploads. */
+    mimeType?: string;
+    /** Y.Text field name carrying the document text. Default 'content'. The
+     *  live binding MUST use the same field. */
+    textField?: string;
+    /** Layout schema version. Default 1. */
+    layoutVersion?: number;
+}
+export declare function createTextCollabContentAdapter(options: TextCollabContentAdapterOptions): CollabContentAdapter;
+/**
+ * Rebuild a CollabContentAdapter from a serializable descriptor (produced by a
+ * host factory and shipped across the process boundary). Returns null for an
+ * unknown descriptor kind so callers can fall back gracefully.
+ */
+export declare function reconstructCollabContentAdapterFromDescriptor(descriptor: CollabAdapterDescriptor): CollabContentAdapter | null;
+//# sourceMappingURL=createTextCollabContentAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTextCollabContentAdapter.d.ts","sourceRoot":"","sources":["../../src/collab/createTextCollabContentAdapter.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EACV,uBAAuB,EACvB,oBAAoB,EAErB,MAAM,oBAAoB,CAAC;AAE5B,8DAA8D;AAC9D,eAAO,MAAM,yBAAyB,YAAY,CAAC;AAEnD,MAAM,WAAW,+BAA+B;IAC9C;iFAC6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB;+DAC2D;IAC3D,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;gDAC4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAWD,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,oBAAoB,CAoDtB;AAED;;;;GAIG;AACH,wBAAgB,6CAA6C,CAC3D,UAAU,EAAE,uBAAuB,GAClC,oBAAoB,GAAG,IAAI,CAW7B"}

package/dist/collab/createTextCollabContentAdapter.js

@@ -0,0 +1,79 @@
+/** Default `Y.Text` field name used when none is supplied. */
+export const TEXT_COLLAB_DEFAULT_FIELD = 'content';
+function decodeSource(source) {
+    if (typeof source === 'string')
+        return source;
+    try {
+        return new TextDecoder('utf-8').decode(source);
+    }
+    catch {
+        return '';
+    }
+}
+export function createTextCollabContentAdapter(options) {
+    const field = options.textField ?? TEXT_COLLAB_DEFAULT_FIELD;
+    const layoutVersion = options.layoutVersion ?? 1;
+    const getText = (yDoc) => yDoc.getText(field);
+    return {
+        documentType: options.documentType,
+        fileExtensions: options.fileExtensions,
+        mimeType: options.mimeType,
+        layoutVersion,
+        // Lets the host rebuild this adapter in another process (e.g. Electron
+        // main) without loading the extension. See reconstruct fn below.
+        serializableDescriptor: {
+            kind: 'text',
+            documentType: options.documentType,
+            fileExtensions: options.fileExtensions,
+            mimeType: options.mimeType,
+            textField: field,
+            layoutVersion,
+        },
+        isEmpty(yDoc) {
+            return getText(yDoc).length === 0;
+        },
+        seedFromFile(yDoc, source) {
+            const text = decodeSource(source);
+            if (!text)
+                return;
+            const yText = getText(yDoc);
+            // Guard against a concurrent seed during the open race.
+            if (yText.length > 0)
+                return;
+            yText.insert(0, text);
+        },
+        applyFromFile(yDoc, source) {
+            const text = decodeSource(source);
+            yDoc.transact(() => {
+                const yText = getText(yDoc);
+                if (yText.length > 0)
+                    yText.delete(0, yText.length);
+                if (text.length > 0)
+                    yText.insert(0, text);
+            });
+        },
+        exportToFile(yDoc) {
+            return getText(yDoc).toString();
+        },
+        toPlainText(yDoc) {
+            return getText(yDoc).toString();
+        },
+    };
+}
+/**
+ * Rebuild a CollabContentAdapter from a serializable descriptor (produced by a
+ * host factory and shipped across the process boundary). Returns null for an
+ * unknown descriptor kind so callers can fall back gracefully.
+ */
+export function reconstructCollabContentAdapterFromDescriptor(descriptor) {
+    if (descriptor.kind === 'text') {
+        return createTextCollabContentAdapter({
+            documentType: descriptor.documentType,
+            fileExtensions: descriptor.fileExtensions,
+            mimeType: descriptor.mimeType,
+            textField: descriptor.textField,
+            layoutVersion: descriptor.layoutVersion,
+        });
+    }
+    return null;
+}

package/dist/createReadOnlyHost.d.ts

@@ -29,6 +29,11 @@ export interface ReadOnlyHostOptions {
     fileName: string;
     /** Optional synthetic file path (defaults to `/shared/{fileName}`) */
     filePath?: string;
+    /**
+     * Whether this host represents an inline embed (vs. a full tab/share viewer).
+     * When true, extensions may suppress chrome that doesn't fit inline contexts.
+     */
+    embedded?: boolean;
 }
 export interface ReadOnlyHost extends EditorHost {
     /** Update the theme (call from viewer chrome's theme toggle) */

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;CACnB;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,CAyDd"}
+{"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"}

package/dist/createReadOnlyHost.js

@@ -36,6 +36,7 @@ export function createReadOnlyHost(content, opts) {
         filePath: opts.filePath ?? `/shared/${opts.fileName}`,
         fileName: opts.fileName,
         readOnly: true,
+        embedded: opts.embedded ?? false,
         theme: currentTheme,
         isActive: true,
         // -- Content loading --
@@ -53,6 +54,9 @@ export function createReadOnlyHost(content, opts) {
         setDirty: () => { },
         onSaveRequested: () => () => { },
         onFileChanged: () => () => { },
+        // readOnly never flips for the share viewer; the callback is held but
+        // never invoked.
+        onReadOnlyChanged: () => () => { },
         openHistory: () => { },
         registerMenuItems: (_items) => { },
         registerEditorAPI: () => { },

package/dist/externals.d.ts

@@ -9,15 +9,15 @@
  * Extensions should bundle their own utility libraries (zustand, lodash, etc.)
  * for version independence.
  */
-export declare const REQUIRED_EXTERNALS: readonly ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime", "lexical", "@lexical/react/LexicalComposerContext", "@lexical/react/useLexicalEditable", "@lexical/react/useLexicalNodeSelection", "@lexical/utils", "@lexical/markdown"];
+export declare const REQUIRED_EXTERNALS: readonly ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime", "lexical", "@lexical/react/LexicalComposerContext", "@lexical/react/useLexicalEditable", "@lexical/react/useLexicalNodeSelection", "@lexical/utils", "@lexical/markdown", "yjs"];
 /**
  * Regex patterns for externals that match multiple modules.
  */
-export declare const EXTERNAL_PATTERNS: readonly [RegExp, RegExp];
+export declare const EXTERNAL_PATTERNS: readonly [RegExp, RegExp, RegExp];
 /**
  * Combined externals for rollup configuration.
  * Use this in rollupOptions.external
  */
-export declare const ROLLUP_EXTERNALS: readonly ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime", "lexical", "@lexical/react/LexicalComposerContext", "@lexical/react/useLexicalEditable", "@lexical/react/useLexicalNodeSelection", "@lexical/utils", "@lexical/markdown", RegExp, RegExp, "@nimbalyst/editor-context"];
+export declare const ROLLUP_EXTERNALS: readonly ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime", "lexical", "@lexical/react/LexicalComposerContext", "@lexical/react/useLexicalEditable", "@lexical/react/useLexicalNodeSelection", "@lexical/utils", "@lexical/markdown", "yjs", RegExp, RegExp, RegExp, "@nimbalyst/editor-context"];
 export type RequiredExternal = (typeof REQUIRED_EXTERNALS)[number];
 //# sourceMappingURL=externals.d.ts.map

package/dist/externals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"externals.d.ts","sourceRoot":"","sources":["../src/externals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,6QAerB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB,2BAGpB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,gBAAgB,0TAInB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"externals.d.ts","sourceRoot":"","sources":["../src/externals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,oRAoBrB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB,mCAMpB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,gBAAgB,yUAInB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/externals.js

@@ -23,6 +23,10 @@ export const REQUIRED_EXTERNALS = [
     '@lexical/react/useLexicalNodeSelection',
     '@lexical/utils',
     '@lexical/markdown',
+    // yJS - collaboration bindings share the host's Y.Doc instance.
+    // `instanceof Y.Doc` checks fail if an extension bundles its own yjs
+    // copy, so this MUST be externalized (same constraint as React).
+    'yjs',
 ];
 /**
  * Regex patterns for externals that match multiple modules.
@@ -30,6 +34,9 @@ export const REQUIRED_EXTERNALS = [
 export const EXTERNAL_PATTERNS = [
     /^@lexical\//,
     /^@nimbalyst\/runtime/,
+    // y-protocols ships submodules like `y-protocols/awareness` and
+    // `y-protocols/sync`. All of them must resolve to the host's copy.
+    /^y-protocols(\/.*)?$/,
 ];
 /**
  * Combined externals for rollup configuration.

package/dist/index.d.ts

@@ -25,9 +25,13 @@
 export { REQUIRED_EXTERNALS, EXTERNAL_PATTERNS, ROLLUP_EXTERNALS, type RequiredExternal, } from './externals.js';
 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 { useDocumentPath, type DocumentPathContextValue, } from './documentPath.js';
 export { MaterialSymbol } from './MaterialSymbol.js';
 export { createReadOnlyHost, type ReadOnlyHost, type ReadOnlyHostOptions, } from './createReadOnlyHost.js';
 export { copyToClipboard, readClipboard } from './clipboard.js';
 export { validateExtensionBundle, printValidationResult, type ValidationResult, } from './validate.js';
+export { validateBackendModules, assertBackendModulesValid, effectiveModulePermissions, validateAgentProviders, assertAgentProvidersValid, extractBackendModuleIds, MAX_AGENT_PROVIDERS_PER_EXTENSION, type BackendModuleValidationIssue, type AgentProviderValidationIssue, } from './manifestValidation.js';
+export type { AgentProtocol, ProtocolEvent, ProtocolMessage, ProtocolSession, SessionOptions, ProtocolEventType, ToolResult as ProtocolToolResult, MCPServerConfig, RawProtocolSession, AgentProtocolHost, PermissionMode, McpToolDefinition, } from './agents/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AAGxB,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,SAAS,GACf,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,eAAe,EACf,KAAK,wBAAwB,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AAGxB,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,SAAS,GACf,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,GAClC,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,8BAA8B,EAC9B,6CAA6C,EAC7C,yBAAyB,EACzB,KAAK,+BAA+B,GACrC,MAAM,4CAA4C,CAAC;AAGpD,OAAO,EACL,eAAe,EACf,KAAK,wBAAwB,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,EAC1B,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,EACvB,iCAAiC,EACjC,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,GAClC,MAAM,yBAAyB,CAAC;AAYjC,YAAY,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,UAAU,IAAI,kBAAkB,EAChC,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,GAClB,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -28,6 +28,8 @@ export { REQUIRED_EXTERNALS, EXTERNAL_PATTERNS, ROLLUP_EXTERNALS, } from './exte
 export * from './types/index.js';
 // Re-export hooks
 export { useEditorLifecycle, } from './useEditorLifecycle.js';
+export { useCollaborativeEditor, COLLAB_INIT_ORIGIN, } from './useCollaborativeEditor.js';
+export { createTextCollabContentAdapter, reconstructCollabContentAdapterFromDescriptor, TEXT_COLLAB_DEFAULT_FIELD, } from './collab/createTextCollabContentAdapter.js';
 // Re-export host-provided editor context and UI helpers for extensions.
 export { useDocumentPath, } from './documentPath.js';
 export { MaterialSymbol } from './MaterialSymbol.js';
@@ -37,3 +39,4 @@ export { createReadOnlyHost, } from './createReadOnlyHost.js';
 export { copyToClipboard, readClipboard } from './clipboard.js';
 // Re-export validation
 export { validateExtensionBundle, printValidationResult, } from './validate.js';
+export { validateBackendModules, assertBackendModulesValid, effectiveModulePermissions, validateAgentProviders, assertAgentProvidersValid, extractBackendModuleIds, MAX_AGENT_PROVIDERS_PER_EXTENSION, } from './manifestValidation.js';

package/dist/manifestValidation.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Pure (no Node/Electron deps) validation helpers for manifest fields.
+ *
+ * Runs at both build time (via validate.ts, which reads manifest.json from
+ * disk) and runtime (when the host loads an extension and needs to refuse
+ * invalid contributions). Keep this file dependency-free so it can be bundled
+ * into either context without dragging in fs/path.
+ */
+import type { ExtensionPermissionId } from './types/permissions.js';
+/**
+ * Manifest validation rejects extensions declaring more than this many AI
+ * agent providers. Chosen by symmetry with
+ * {@link MAX_BACKEND_MODULES_PER_EXTENSION}: an extension that ships more than
+ * a handful of agent providers is almost certainly mis-modeled (split it into
+ * multiple extensions, or surface them as models on one provider). The cap
+ * also keeps the settings UI -- which lists each provider as its own row --
+ * from running away.
+ */
+export declare const MAX_AGENT_PROVIDERS_PER_EXTENSION = 4;
+export interface BackendModuleValidationIssue {
+    /** The module being validated, or undefined for whole-extension issues */
+    moduleId?: string;
+    message: string;
+    /**
+     * Non-fatal issues (e.g., a deprecated permission id that the validator
+     * silently drops) carry `severity: "warning"`. Callers that fail builds
+     * on issues should ignore warnings.
+     */
+    severity?: 'error' | 'warning';
+}
+/**
+ * Validate the `contributions.backendModules` array on a manifest.
+ * Returns the list of problems found - empty means valid.
+ *
+ * Callers decide whether to treat issues as fatal (host loader: refuse the
+ * extension) or as warnings (build-time validator: print and continue with
+ * non-zero exit).
+ */
+export declare function validateBackendModules(backendModules: unknown): BackendModuleValidationIssue[];
+/**
+ * Convenience wrapper that throws if any fatal issues are found. Warnings
+ * (currently: deprecated permission ids) are surfaced via the issues array
+ * but never throw, so an extension that still references `spawn-process`
+ * keeps loading -- the host just drops the id when computing effective
+ * permissions.
+ *
+ * Use this in main-process load paths where invalid manifests should refuse
+ * the extension outright.
+ */
+export declare function assertBackendModulesValid(extensionId: string, backendModules: unknown): void;
+/**
+ * Filter a raw `permissions` array on a backend-module contribution down to
+ * the ids the host actually understands. Deprecated catalog ids
+ * (`spawn-process`, `network-loopback`, `network-internet`, `filesystem`)
+ * are dropped silently -- they never gated anything inside the backend
+ * runtime, so the host treats them as no-ops. Unknown ids are also dropped;
+ * `validateBackendModules` raises a separate error for those, so the loader
+ * will refuse the module before this is consulted in earnest.
+ */
+export declare function effectiveModulePermissions(raw: unknown): ExtensionPermissionId[];
+/**
+ * Issue surface used by {@link validateAgentProviders}. Shaped to mirror
+ * {@link BackendModuleValidationIssue} so callers can pool the two streams
+ * (build-time validator, runtime loader) through one error pipeline.
+ */
+export interface AgentProviderValidationIssue {
+    /** The provider being validated, or undefined for whole-extension issues */
+    providerId?: string;
+    message: string;
+    /**
+     * Non-fatal issues carry `severity: "warning"`. Callers that fail builds
+     * on issues should ignore warnings.
+     */
+    severity?: 'error' | 'warning';
+}
+/**
+ * Extract the set of declared backend-module ids from a manifest's
+ * `contributions.backendModules` array. Used by
+ * {@link validateAgentProviders} so the `backendModuleId` cross-check does
+ * not need the caller to pre-compute the set.
+ *
+ * Returns an empty set if `backendModules` is missing or malformed. Exported
+ * so build tooling can reuse the same extraction logic when checking entry
+ * files against the declared modules.
+ */
+export declare function extractBackendModuleIds(backendModules: unknown): Set<string>;
+/**
+ * Validate the `contributions.aiAgentProviders` array on a manifest.
+ *
+ * AI agent providers are surfaced in Nimbalyst's chat / agent UI as selectable
+ * providers (alongside built-in Claude Code, Claude, OpenAI, etc.). Each
+ * provider is implemented by a backend module that runs outside the renderer
+ * (so it can drive a CLI, hold long-lived processes, or speak a custom
+ * protocol). The contribution shape, in practice:
+ *
+ *   {
+ *     id: string,                       // unique within the extension
+ *     displayName: string,              // shown in the provider dropdown
+ *     backendModuleId: string,          // must match a declared backendModule
+ *     models?: Array<{ id, name, ... }> // models the provider advertises
+ *     toolFileLinks?: { [toolName]: ... } // optional UI hint table
+ *   }
+ *
+ * This validator checks the manifest-side wiring; it does not introspect the
+ * bundle. See {@link validateExtensionBundle} (Node-only) for the bundle-side
+ * check that the referenced backend module actually exports an
+ * `activate`/`createAgentProvider` function.
+ *
+ * Returns the list of problems found - empty means valid.
+ */
+export declare function validateAgentProviders(aiAgentProviders: unknown, backendModules: unknown): AgentProviderValidationIssue[];
+/**
+ * Convenience wrapper that throws if any fatal aiAgentProviders issues are
+ * found. Mirrors {@link assertBackendModulesValid}. Use this in main-process
+ * load paths where invalid manifests should refuse the extension outright.
+ */
+export declare function assertAgentProvidersValid(extensionId: string, aiAgentProviders: unknown, backendModules: unknown): void;
+//# sourceMappingURL=manifestValidation.d.ts.map

package/dist/manifestValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifestValidation.d.ts","sourceRoot":"","sources":["../src/manifestValidation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAGV,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,IAAI,CAAC;AAuCnD,MAAM,WAAW,4BAA4B;IAC3C,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,OAAO,GACtB,4BAA4B,EAAE,CAoKhC;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,OAAO,GACtB,IAAI,CAYN;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,GACX,qBAAqB,EAAE,CAazB;AAED;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAW5E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,OAAO,EACzB,cAAc,EAAE,OAAO,GACtB,4BAA4B,EAAE,CAgMhC;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,OAAO,EACzB,cAAc,EAAE,OAAO,GACtB,IAAI,CAYN"}