@vscode/web-editors 0.0.2-11 → 0.0.2-111

package/dist/index.d.ts

@@ -2143,11 +2143,14 @@ declare const ZodReadonly: $constructor<ZodReadonly>;
 declare const zEditorCapabilities: ZodObject<{
   supportsContentEdits: ZodOptional<ZodBoolean>;
   supportsOptions: ZodOptional<ZodBoolean>;
+  supportsPresentation: ZodOptional<ZodBoolean>;
 }, $strip>;
 declare const zHostCapabilities: ZodObject<{
   supportsContentEdits: ZodOptional<ZodBoolean>;
   supportsOptions: ZodOptional<ZodBoolean>;
   supportsForceUpdate: ZodOptional<ZodBoolean>;
+  supportsHostTransport: ZodOptional<ZodBoolean>;
+  supportsPresentation: ZodOptional<ZodBoolean>;
 }, $strip>;
 declare const zTextEdit: ZodObject<{
   offset: ZodNumber;
@@ -2175,14 +2178,39 @@ declare const zWebEditorUpdate: ZodObject<{
   acknowledgedClientRevision: ZodOptional<ZodNumber>;
   force: ZodOptional<ZodBoolean>;
 }, $strip>;
+/** How an embedding host currently presents the editor. */
+declare const zPresentationMode: ZodEnum<{
+  inline: "inline";
+  "full-width": "full-width";
+  "full-view": "full-view";
+}>;
+/**
+ * Presentation controls the editor asks its embedding host for. The host's own
+ * configuration takes precedence over these preferences.
+ */
+declare const zPresentationPreferences: ZodObject<{
+  resizable: ZodOptional<ZodBoolean>;
+  fullWidth: ZodOptional<ZodBoolean>;
+  fullView: ZodOptional<ZodBoolean>;
+  minHeight: ZodOptional<ZodNumber>;
+  maxAutomaticHeight: ZodOptional<ZodNumber>;
+}, $strip>;
 type ContentEdit = output<typeof zContentEdit>;
 type TextEdit = output<typeof zTextEdit>;
 type EditorCapabilities = output<typeof zEditorCapabilities>;
 type HostCapabilities = output<typeof zHostCapabilities>;
 type WebEditorUpdate = output<typeof zWebEditorUpdate>;
+type PresentationMode = output<typeof zPresentationMode>;
+type PresentationPreferences = output<typeof zPresentationPreferences>;
 type ContentType = "text" | "json";
 declare const webEditorHostInterface: any;
 declare const webEditorInterface: any;
+declare const webEditorHostTransportInterface: any;
+declare const webEditorClientTransportInterface: any;
+/** Methods the editor exposes to a presenting host. */
+declare const webEditorPresentationInterface: any;
+/** Methods a presenting host exposes to the editor. */
+declare const webEditorPresentationHostInterface: any;
 declare const zEmbeddedAppDescriptor: ZodObject<{
   handleId: ZodString;
   appId: ZodString;
@@ -2205,6 +2233,10 @@ declare const vscodeAppEmbeddingEventsInterface: any;
 type WebEditorHostProxy = InterfaceClient<typeof webEditorHostInterface>;
 /** Typed proxy used by the host to invoke editor methods. */
 type WebEditorProxy = InterfaceClient<typeof webEditorInterface>;
+type WebEditorHostTransportProxy = InterfaceClient<typeof webEditorHostTransportInterface>;
+type WebEditorClientTransportProxy = InterfaceClient<typeof webEditorClientTransportInterface>;
+type WebEditorPresentationProxy = InterfaceClient<typeof webEditorPresentationInterface>;
+type WebEditorPresentationHostProxy = InterfaceClient<typeof webEditorPresentationHostInterface>;
 /** Typed proxy used by an app to invoke `vscode-app-host` methods. */
 type VsCodeAppHostProxy = InterfaceClient<typeof vscodeAppHostInterface>;
 type VsCodeAppEmbeddingEventsProxy = InterfaceClient<typeof vscodeAppEmbeddingEventsInterface>;
@@ -2280,6 +2312,16 @@ interface IDisposable {
 type EventListener<T> = (event: T) => void;
 type Event<T> = (listener: EventListener<T>) => IDisposable;
 //#endregion
+//#region src/hostTransport.d.ts
+/**
+ * Optional message transport between a web editor and its host.
+ */
+interface HostTransport {
+  readonly onMessage: Event<JsonValue>;
+  /** Sends a notification to the host. */
+  sendMessage(message: JsonValue): void;
+}
+//#endregion
 //#region src/host/WebEditorHost.d.ts
 interface WebEditorHostOptions {
   /**
@@ -2302,6 +2344,14 @@ interface WebEditorHostOptions {
   jsonFormat?: JsonFormatOptions;
   /** Host capabilities advertised on `initialized`. */
   capabilities?: HostCapabilities;
+  /** Optional message transport to expose to the editor. */
+  hostTransport?: HostTransport;
+  /**
+   * The host presents the editor inline (for example as a block in a document)
+   * and exchanges presentation state with editors that support it: see
+   * {@link WebEditorHost.setPresentationMode} and the presentation events.
+   */
+  supportsPresentation?: boolean;
   /** Called when the editor sends malformed input. Defaults to `console.error`. */
   onError?: (message: string, detail?: unknown) => void;
 }
@@ -2315,16 +2365,21 @@ interface WebEditorHostOptions {
 declare class WebEditorHost implements IDisposable {
   private readonly _connection;
   private readonly _editor;
+  private readonly _clientTransport;
+  private readonly _presentation;
   private readonly _contentType;
   private readonly _jsonFormat;
   private readonly _onError;
   private readonly _capabilities;
+  private readonly _hostTransportSubscription;
   private _text;
   private _readOnly;
+  private _presentationMode;
   private _serverRevision;
   private _acknowledgedClientRevision;
   private _editorInitialized;
   private _editorCapabilities;
+  private readonly _pendingHostTransportMessages;
   private readonly _onDidChangeText;
   readonly onDidChangeText: Event<{
     text: string;
@@ -2337,6 +2392,12 @@ declare class WebEditorHost implements IDisposable {
   readonly onDidReportSize: Event<{
     height: number;
   }>;
+  private readonly _onDidSetPresentationPreferences;
+  /** The editor replaced its presentation preferences. Only fires with `supportsPresentation`. */
+  readonly onDidSetPresentationPreferences: Event<PresentationPreferences>;
+  private readonly _onDidRequestExitFullView;
+  /** The editor asked to leave full view. Only fires with `supportsPresentation`. */
+  readonly onDidRequestExitFullView: Event<void>;
   constructor(options: WebEditorHostOptions);
   /** The text the host believes the document currently holds. */
   getText(): string;
@@ -2354,6 +2415,11 @@ declare class WebEditorHost implements IDisposable {
    */
   reuse(text: string, readOnly: boolean): void;
   getReadOnly(): boolean;
+  /**
+   * Tell the editor how the host presents it. Sent to editors that support
+   * presentation once they initialized, and again after they reconnect.
+   */
+  setPresentationMode(mode: PresentationMode): void;
   setReadOnly(readOnly: boolean): void;
   /**
    * Push fine-grained edits to the editor.
@@ -2363,6 +2429,7 @@ declare class WebEditorHost implements IDisposable {
   dispose(): void;
   private _pushFullUpdate;
   private _pushAcknowledgement;
+  private _pushPresentationMode;
   private _acknowledgeAndRestore;
 }
 //#endregion
@@ -2463,11 +2530,19 @@ interface WebEditorClientState {
 declare class WebEditorClient implements IDisposable {
   private readonly _connection;
   private readonly _host;
+  private readonly _hostTransportProxy;
+  private readonly _presentationHost;
   private readonly _onError;
+  private _hostTransport;
   private _content;
   private _readOnly;
   private _options;
   private _hostCapabilities;
+  private _connected;
+  private _presentationMode;
+  private _presentationPreferences;
+  private readonly _pendingHostTransportMessages;
+  private _hostTransportActivated;
   private _clientRevision;
   private _basedOnServerRevision;
   /** Number of un-acked local revisions. While > 0 the editor has pending edits. */
@@ -2490,6 +2565,12 @@ declare class WebEditorClient implements IDisposable {
   readonly onDidChangeOptions: Event<{
     options: JsonValue;
   }>;
+  private readonly _onDidChangePresentationMode;
+  /** The embedding host changed how it presents this editor. See {@link getPresentationMode}. */
+  readonly onDidChangePresentationMode: Event<{
+    mode: PresentationMode;
+  }>;
+  private readonly _onDidReceiveHostMessage;
   /** Resolves once the host has acknowledged `initialized`. */
   readonly onDidConnect: Promise<{
     capabilities: HostCapabilities | undefined;
@@ -2502,6 +2583,8 @@ declare class WebEditorClient implements IDisposable {
    * second one.
    */
   get connection(): HubRpcConnection;
+  /** Optional notification transport supplied by the web editor host. */
+  get hostTransport(): HostTransport | undefined;
   getContent(): JsonValue;
   getReadOnly(): boolean;
   getOptions(): JsonValue;
@@ -2512,10 +2595,24 @@ declare class WebEditorClient implements IDisposable {
    */
   applyEdits(edits: readonly ContentEdit[]): void;
   /**
-   * Report the editor's current laid-out content height (px) to the host.
-   * A host embedding this editor in an iframe uses it to size the frame.
+   * Report the editor's preferred content height (px): the height it needs to
+   * show its content without scrolling, independent of the frame's current
+   * height. A host embedding this editor in an iframe sizes the frame to it.
    */
   reportSize(height: number): void;
+  /**
+   * How an embedding host currently presents this editor, or `undefined` when
+   * the host does not present it inline (for example a standalone editor).
+   */
+  getPresentationMode(): PresentationMode | undefined;
+  /**
+   * Ask a presenting host for presentation controls (resize grips, full view).
+   * Replaces earlier preferences; sent once connected, and ignored by hosts
+   * that do not present the editor inline.
+   */
+  setPresentationPreferences(preferences: PresentationPreferences): void;
+  /** Ask a presenting host to leave full view. */
+  exitFullView(): void;
   dispose(): void;
   private _handleUpdate;
   private _handleApplyContentEdits;
@@ -2654,7 +2751,20 @@ declare class VsCodeAppHostClient {
   configureEditorAssociation(extension: string, options?: {
     dismissable?: boolean;
   }): Promise<EditorAssociationResult>;
+  /**
+   * This editor tab's view state, or `undefined` when none is set. VS Code
+   * restores it with the tab (for example after a window reload); a newly
+   * opened tab starts without one. Validate it like any other persisted
+   * input, since it may come from an older version of the app.
+   */
+  getViewState(): Promise<unknown>;
+  /**
+   * Replace this editor tab's view state with a JSON value, for example
+   * scroll positions or selections. Use per-app storage for state shared by
+   * every tab. Rejects for values too large to persist and in embedded apps.
+   */
+  setViewState(value: unknown): Promise<void>;
 }
 //#endregion
-export { AppContext, type ConnectionInput, ContentEdit, ContentType, EditorAssociationResult, EditorCapabilities, EditorRegistrationStatus, EditorScope, EmbeddedAppAccessOptions, EmbeddedAppDescriptor, EmbeddedAppHandle, EmbeddingContext, type Event, HostCapabilities, type IDisposable, JsonFormatOptions, JsonValue, type MessageEndpoint, type MessageLikeEvent, ScopeRegistration, TextEdit, VsCodeAppEmbeddingEventsProxy, VsCodeAppHostClient, VsCodeAppHostClientOptions, VsCodeAppHostProxy, WebEditorClient, WebEditorClientOptions, WebEditorClientState, WebEditorHost, WebEditorHostOptions, WebEditorHostProxy, WebEditorProxy, WebEditorUpdate, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorHostInterface, webEditorInterface };
+export { AppContext, type ConnectionInput, ContentEdit, ContentType, EditorAssociationResult, EditorCapabilities, EditorRegistrationStatus, EditorScope, EmbeddedAppAccessOptions, EmbeddedAppDescriptor, EmbeddedAppHandle, EmbeddingContext, type Event, HostCapabilities, HostTransport, type IDisposable, JsonFormatOptions, JsonValue, type MessageEndpoint, type MessageLikeEvent, PresentationMode, PresentationPreferences, ScopeRegistration, TextEdit, VsCodeAppEmbeddingEventsProxy, VsCodeAppHostClient, VsCodeAppHostClientOptions, VsCodeAppHostProxy, WebEditorClient, WebEditorClientOptions, WebEditorClientState, WebEditorClientTransportProxy, WebEditorHost, WebEditorHostOptions, WebEditorHostProxy, WebEditorHostTransportProxy, WebEditorPresentationHostProxy, WebEditorPresentationProxy, WebEditorProxy, WebEditorUpdate, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorClientTransportInterface, webEditorHostInterface, webEditorHostTransportInterface, webEditorInterface, webEditorPresentationHostInterface, webEditorPresentationInterface };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4120,12 +4120,17 @@ function superRefine(fn, params) {
 const zJsonValue = unknown();
 const zEditorCapabilities = object({
 	supportsContentEdits: boolean().optional(),
-	supportsOptions: boolean().optional()
+	supportsOptions: boolean().optional(),
+	/** The editor implements `web-editor-presentation` (see {@link webEditorPresentationInterface}). */
+	supportsPresentation: boolean().optional()
 });
 const zHostCapabilities = object({
 	supportsContentEdits: boolean().optional(),
 	supportsOptions: boolean().optional(),
-	supportsForceUpdate: boolean().optional()
+	supportsForceUpdate: boolean().optional(),
+	supportsHostTransport: boolean().optional(),
+	/** The host presents the editor inline and implements `web-editor-presentation-host`. */
+	supportsPresentation: boolean().optional()
 });
 const zTextEdit = object({
 	offset: number().int().nonnegative(),
@@ -4149,6 +4154,28 @@ const zWebEditorUpdate = object({
 	acknowledgedClientRevision: number().int().nonnegative().optional(),
 	force: boolean().optional()
 });
+/** How an embedding host currently presents the editor. */
+const zPresentationMode = _enum([
+	"inline",
+	"full-width",
+	"full-view"
+]);
+const zEditorHeight = number().positive().max(1e4);
+/**
+* Presentation controls the editor asks its embedding host for. The host's own
+* configuration takes precedence over these preferences.
+*/
+const zPresentationPreferences = object({
+	/** A height grip; dragging near the automatic (content) height snaps back to it. */
+	resizable: boolean().optional(),
+	/** A width grip that widens the editor up to the host's viewport. */
+	fullWidth: boolean().optional(),
+	/** A toolbar action that fills the host's viewport. */
+	fullView: boolean().optional(),
+	minHeight: zEditorHeight.optional(),
+	/** Upper bound for the automatic height; users can still resize beyond it. */
+	maxAutomaticHeight: zEditorHeight.optional()
+});
 const webEditorHostInterface = defineInterface({
 	id: "web-editor-host",
 	description: "Methods the host exposes to the editor (web-editor/0.12)."
@@ -4167,9 +4194,12 @@ const webEditorHostInterface = defineInterface({
 		basedOnServerRevision: number().int().nonnegative()
 	})),
 	/**
-	* The editor reports its laid-out content height (px). An embedding host
-	* that reserves block space (e.g. an iframe with no intrinsic height)
-	* uses this to size the frame once the guest has measured itself.
+	* The editor reports its preferred content height (px): the height it needs
+	* to show its content without scrolling, independent of the frame's current
+	* height. Measure the content, not the viewport or document, which follow
+	* the frame. An embedding host that reserves block space (e.g. an iframe
+	* with no intrinsic height) sizes the frame to it and uses it as the
+	* automatic height that user resizing snaps back to.
 	*/
 	reportSize: notificationType(object({ height: number().nonnegative() }))
 });
@@ -4185,6 +4215,31 @@ const webEditorInterface = defineInterface({
 	})),
 	getContentSchema: requestType(object({}), object({ schema: zJsonValue }))
 });
+const webEditorHostTransportInterface = defineInterface({
+	id: "web-editor-host-transport",
+	description: "Optional messages the web editor sends to its host."
+}, { message: notificationType(object({ message: zJsonValue })) });
+const webEditorClientTransportInterface = defineInterface({
+	id: "web-editor-client-transport",
+	description: "Optional messages the web editor host sends to the editor."
+}, { message: notificationType(object({ message: zJsonValue })) });
+/** Methods the editor exposes to a presenting host. */
+const webEditorPresentationInterface = defineInterface({
+	id: "web-editor-presentation",
+	description: "How the embedding host currently presents the editor."
+}, { 
+/** Sent once the editor initialized, and whenever the mode changes. */
+changed: notificationType(object({ mode: zPresentationMode })) });
+/** Methods a presenting host exposes to the editor. */
+const webEditorPresentationHostInterface = defineInterface({
+	id: "web-editor-presentation-host",
+	description: "Presentation preferences and actions of an embedded editor."
+}, {
+	/** Replaces the editor's previous preferences. */
+	setPreferences: notificationType(zPresentationPreferences),
+	/** Asks the host to leave full view, for example when the user presses Escape. */
+	exitFullView: notificationType(object({}))
+});
 /** Per-scope registration: `registered` (toolbar button) and `isDefault` (auto-open). */
 const zScopeRegistration = object({
 	registered: boolean(),
@@ -4260,7 +4315,21 @@ const vscodeAppHostInterface = defineInterface({
 		workspace: zScopeRegistration,
 		hasWorkspace: boolean(),
 		changed: boolean()
-	}))
+	})),
+	/**
+	* The view state of this editor tab, such as scroll positions or
+	* selections, as last set by {@link setViewState}. `value` is omitted
+	* when none is set. VS Code restores it when it restores the tab (for
+	* example after a window reload), but a newly opened tab starts
+	* without one. Only the top-level app of a tab has view state.
+	*/
+	getViewState: requestType(object({}), object({ value: zJsonValue.optional() })),
+	/**
+	* Replace this editor tab's view state with a JSON value. The host
+	* rejects values too large to persist with the tab, and calls from
+	* embedded apps.
+	*/
+	setViewState: requestType(object({ value: zJsonValue }), object({}))
 });
 /** Host-to-parent notifications for loaded child runtime changes. */
 const vscodeAppEmbeddingEventsInterface = defineInterface({
@@ -4382,22 +4451,33 @@ var Emitter = class {
 var WebEditorHost = class {
 	_connection;
 	_editor;
+	_clientTransport;
+	_presentation;
 	_contentType;
 	_jsonFormat;
 	_onError;
 	_capabilities;
+	_hostTransportSubscription;
 	_text;
 	_readOnly;
+	_presentationMode;
 	_serverRevision = 0;
 	_acknowledgedClientRevision = 0;
 	_editorInitialized = false;
 	_editorCapabilities;
+	_pendingHostTransportMessages = [];
 	_onDidChangeText = new Emitter();
 	onDidChangeText = this._onDidChangeText.event;
 	_onDidInitialize = new Emitter();
 	onDidInitialize = this._onDidInitialize.event;
 	_onDidReportSize = new Emitter();
 	onDidReportSize = this._onDidReportSize.event;
+	_onDidSetPresentationPreferences = new Emitter();
+	/** The editor replaced its presentation preferences. Only fires with `supportsPresentation`. */
+	onDidSetPresentationPreferences = this._onDidSetPresentationPreferences.event;
+	_onDidRequestExitFullView = new Emitter();
+	/** The editor asked to leave full view. Only fires with `supportsPresentation`. */
+	onDidRequestExitFullView = this._onDidRequestExitFullView.event;
 	constructor(options) {
 		this._connection = options.connection;
 		this._contentType = options.contentType ?? "text";
@@ -4405,8 +4485,14 @@ var WebEditorHost = class {
 		this._readOnly = options.readOnly ?? false;
 		this._jsonFormat = options.jsonFormat ?? {};
 		this._onError = options.onError ?? ((m, d) => console.error("WebEditorHost:", m, d));
-		this._capabilities = options.capabilities ?? { supportsForceUpdate: true };
+		this._capabilities = {
+			...options.capabilities ?? { supportsForceUpdate: true },
+			supportsHostTransport: options.hostTransport ? true : void 0,
+			supportsPresentation: options.supportsPresentation ? true : void 0
+		};
 		this._editor = this._connection.get(webEditorInterface);
+		this._clientTransport = this._connection.get(webEditorClientTransportInterface);
+		this._presentation = this._connection.get(webEditorPresentationInterface);
 		this._connection.register(webEditorHostInterface, {
 			initialized: (params) => {
 				if (params.contentType !== this._contentType) this._onError(`Editor contentType "${params.contentType}" does not match host "${this._contentType}"`);
@@ -4415,6 +4501,8 @@ var WebEditorHost = class {
 				this._serverRevision = 0;
 				this._acknowledgedClientRevision = 0;
 				this._pushFullUpdate();
+				for (const message of this._pendingHostTransportMessages.splice(0)) this._clientTransport.message({ message });
+				this._pushPresentationMode();
 				this._onDidInitialize.fire({ capabilities: params.capabilities });
 				return {
 					protocolVersion: "web-editor-host/0.12",
@@ -4459,6 +4547,17 @@ var WebEditorHost = class {
 				this._onDidReportSize.fire({ height: params.height });
 			}
 		});
+		if (options.supportsPresentation) this._connection.register(webEditorPresentationHostInterface, {
+			setPreferences: (preferences) => this._onDidSetPresentationPreferences.fire(preferences),
+			exitFullView: () => this._onDidRequestExitFullView.fire()
+		});
+		if (options.hostTransport) {
+			this._connection.register(webEditorHostTransportInterface, { message: ({ message }) => options.hostTransport.sendMessage(message) });
+			this._hostTransportSubscription = options.hostTransport.onMessage((message) => {
+				if (this._editorInitialized) this._clientTransport.message({ message });
+				else this._pendingHostTransportMessages.push(message);
+			});
+		}
 	}
 	/** The text the host believes the document currently holds. */
 	getText() {
@@ -4486,6 +4585,15 @@ var WebEditorHost = class {
 	getReadOnly() {
 		return this._readOnly;
 	}
+	/**
+	* Tell the editor how the host presents it. Sent to editors that support
+	* presentation once they initialized, and again after they reconnect.
+	*/
+	setPresentationMode(mode) {
+		if (this._presentationMode === mode) return;
+		this._presentationMode = mode;
+		this._pushPresentationMode();
+	}
 	setReadOnly(readOnly) {
 		if (this._readOnly === readOnly) return;
 		this._readOnly = readOnly;
@@ -4516,9 +4624,13 @@ var WebEditorHost = class {
 		});
 	}
 	dispose() {
+		this._hostTransportSubscription?.dispose();
 		this._onDidChangeText.dispose();
 		this._onDidInitialize.dispose();
 		this._onDidReportSize.dispose();
+		this._onDidSetPresentationPreferences.dispose();
+		this._onDidRequestExitFullView.dispose();
+		this._pendingHostTransportMessages.length = 0;
 		this._connection.close();
 	}
 	_pushFullUpdate(force) {
@@ -4546,6 +4658,10 @@ var WebEditorHost = class {
 			acknowledgedClientRevision: this._acknowledgedClientRevision
 		});
 	}
+	_pushPresentationMode() {
+		if (!this._editorInitialized || !this._capabilities.supportsPresentation || !this._editorCapabilities?.supportsPresentation || this._presentationMode === void 0) return;
+		this._presentation.changed({ mode: this._presentationMode });
+	}
 	_acknowledgeAndRestore(clientRevision) {
 		this._acknowledgedClientRevision = Math.max(this._acknowledgedClientRevision, clientRevision);
 		this._pushFullUpdate(true);
@@ -4697,11 +4813,19 @@ var HostConnection = class HostConnection {
 var WebEditorClient = class WebEditorClient {
 	_connection;
 	_host;
+	_hostTransportProxy;
+	_presentationHost;
 	_onError;
+	_hostTransport;
 	_content = void 0;
 	_readOnly = false;
 	_options = void 0;
 	_hostCapabilities;
+	_connected = false;
+	_presentationMode;
+	_presentationPreferences;
+	_pendingHostTransportMessages = [];
+	_hostTransportActivated = false;
 	_clientRevision = 0;
 	_basedOnServerRevision = 0;
 	/** Number of un-acked local revisions. While > 0 the editor has pending edits. */
@@ -4714,6 +4838,10 @@ var WebEditorClient = class WebEditorClient {
 	onDidChangeReadOnly = this._onDidChangeReadOnly.event;
 	_onDidChangeOptions = new Emitter();
 	onDidChangeOptions = this._onDidChangeOptions.event;
+	_onDidChangePresentationMode = new Emitter();
+	/** The embedding host changed how it presents this editor. See {@link getPresentationMode}. */
+	onDidChangePresentationMode = this._onDidChangePresentationMode.event;
+	_onDidReceiveHostMessage = new Emitter();
 	/** Resolves once the host has acknowledged `initialized`. */
 	onDidConnect;
 	static async connect(options) {
@@ -4725,6 +4853,8 @@ var WebEditorClient = class WebEditorClient {
 		this._connection = resolveConnection(options.connection);
 		this._onError = options.onError ?? ((m, d) => console.error("WebEditorClient:", m, d));
 		this._host = this._connection.get(webEditorHostInterface);
+		this._hostTransportProxy = this._connection.get(webEditorHostTransportInterface);
+		this._presentationHost = this._connection.get(webEditorPresentationHostInterface);
 		this._connection.register(webEditorInterface, {
 			update: (params) => this._handleUpdate(params),
 			applyContentEdits: (params) => this._handleApplyContentEdits(params),
@@ -4732,12 +4862,38 @@ var WebEditorClient = class WebEditorClient {
 				return { schema: options.getContentSchema ? await options.getContentSchema() : null };
 			}
 		});
+		this._connection.register(webEditorPresentationInterface, { changed: ({ mode }) => {
+			if (mode === this._presentationMode) return;
+			this._presentationMode = mode;
+			this._onDidChangePresentationMode.fire({ mode });
+		} });
+		this._connection.register(webEditorClientTransportInterface, { message: ({ message }) => {
+			if (this._hostTransportActivated) this._onDidReceiveHostMessage.fire(message);
+			else this._pendingHostTransportMessages.push(message);
+		} });
 		this.onDidConnect = this._host.initialized({
 			protocolVersion: "web-editor/0.12",
 			contentType: options.contentType ?? "text",
-			capabilities: options.capabilities
+			capabilities: {
+				...options.capabilities,
+				supportsPresentation: true
+			}
 		}).then((r) => {
 			this._hostCapabilities = r.capabilities;
+			this._connected = true;
+			if (this._presentationPreferences) this.setPresentationPreferences(this._presentationPreferences);
+			if (r.capabilities?.supportsHostTransport) this._hostTransport = {
+				onMessage: (listener) => {
+					const disposable = this._onDidReceiveHostMessage.event(listener);
+					if (!this._hostTransportActivated) {
+						this._hostTransportActivated = true;
+						for (const message of this._pendingHostTransportMessages.splice(0)) listener(message);
+					}
+					return disposable;
+				},
+				sendMessage: (message) => this._hostTransportProxy.message({ message })
+			};
+			else this._pendingHostTransportMessages.length = 0;
 			return { capabilities: r.capabilities };
 		});
 	}
@@ -4749,6 +4905,10 @@ var WebEditorClient = class WebEditorClient {
 	get connection() {
 		return this._connection;
 	}
+	/** Optional notification transport supplied by the web editor host. */
+	get hostTransport() {
+		return this._hostTransport;
+	}
 	getContent() {
 		return this._content;
 	}
@@ -4786,17 +4946,41 @@ var WebEditorClient = class WebEditorClient {
 		});
 	}
 	/**
-	* Report the editor's current laid-out content height (px) to the host.
-	* A host embedding this editor in an iframe uses it to size the frame.
+	* Report the editor's preferred content height (px): the height it needs to
+	* show its content without scrolling, independent of the frame's current
+	* height. A host embedding this editor in an iframe sizes the frame to it.
 	*/
 	reportSize(height) {
 		this._host.reportSize({ height });
 	}
+	/**
+	* How an embedding host currently presents this editor, or `undefined` when
+	* the host does not present it inline (for example a standalone editor).
+	*/
+	getPresentationMode() {
+		return this._presentationMode;
+	}
+	/**
+	* Ask a presenting host for presentation controls (resize grips, full view).
+	* Replaces earlier preferences; sent once connected, and ignored by hosts
+	* that do not present the editor inline.
+	*/
+	setPresentationPreferences(preferences) {
+		this._presentationPreferences = preferences;
+		if (this._connected && this._hostCapabilities?.supportsPresentation) this._presentationHost.setPreferences(preferences);
+	}
+	/** Ask a presenting host to leave full view. */
+	exitFullView() {
+		if (this._connected && this._hostCapabilities?.supportsPresentation) this._presentationHost.exitFullView({});
+	}
 	dispose() {
 		this._onDidChangeContent.dispose();
 		this._onDidApplyHostEdits.dispose();
 		this._onDidChangeReadOnly.dispose();
 		this._onDidChangeOptions.dispose();
+		this._onDidChangePresentationMode.dispose();
+		this._onDidReceiveHostMessage.dispose();
+		this._pendingHostTransportMessages.length = 0;
 		this._connection.close();
 	}
 	_handleUpdate(params) {
@@ -5045,8 +5229,25 @@ var VsCodeAppHostClient = class {
 			dismissable: options?.dismissable
 		});
 	}
+	/**
+	* This editor tab's view state, or `undefined` when none is set. VS Code
+	* restores it with the tab (for example after a window reload); a newly
+	* opened tab starts without one. Validate it like any other persisted
+	* input, since it may come from an older version of the app.
+	*/
+	async getViewState() {
+		return (await this._host.getViewState({})).value;
+	}
+	/**
+	* Replace this editor tab's view state with a JSON value, for example
+	* scroll positions or selections. Use per-app storage for state shared by
+	* every tab. Rejects for values too large to persist and in embedded apps.
+	*/
+	async setViewState(value) {
+		await this._host.setViewState({ value });
+	}
 };
 //#endregion
-export { EmbeddedAppHandle, VsCodeAppHostClient, WebEditorClient, WebEditorHost, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorHostInterface, webEditorInterface };
+export { EmbeddedAppHandle, VsCodeAppHostClient, WebEditorClient, WebEditorHost, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorClientTransportInterface, webEditorHostInterface, webEditorHostTransportInterface, webEditorInterface, webEditorPresentationHostInterface, webEditorPresentationInterface };
 
 //# sourceMappingURL=index.js.map