kviewer 0.1.0 → 0.1.1

package/dist/runtime/composables/useScriptingBridge.js

@@ -0,0 +1,74 @@
+import { getEventBus } from "./useScriptingManager.js";
+export function createScriptingBridge(opts) {
+  const { formFields, scripting, pdfDoc } = opts;
+  const storage = pdfDoc.annotationStorage;
+  const eventBus = getEventBus(scripting);
+  for (const fv of formFields.getAllFieldValues()) {
+    const def = formFields.getFieldById(fv.fieldId);
+    if (!def || def.origin !== "parsed") continue;
+    storage.setValue(fv.fieldId, toStorageShape(def.fieldType, fv.value));
+  }
+  formFields.setValueWriteSink((fieldId, value) => {
+    const def = formFields.getFieldById(fieldId);
+    if (!def || def.origin !== "parsed") return;
+    storage.setValue(fieldId, toStorageShape(def.fieldType, value));
+    scripting.dispatchFieldEvent(fieldId, "Action", value);
+    if (def.fieldType === "checkbox" || def.fieldType === "radio" || def.fieldType === "button") {
+      scripting.dispatchFieldEvent(fieldId, "Mouse Up", value);
+    }
+    if (def.fieldType === "text") {
+      scripting.dispatchFieldEvent(fieldId, "Validate", value);
+    }
+  });
+  const onUpdate = (evt) => {
+    const detail = evt?.detail;
+    if (!detail) return;
+    const primaryId = detail.id ?? evt?.id;
+    if (!primaryId) return;
+    const siblings = Array.isArray(detail.siblings) ? detail.siblings : [];
+    const ids = [primaryId, ...siblings];
+    for (const id of ids) {
+      const def = formFields.getFieldById(id);
+      if (!def || def.origin !== "parsed") continue;
+      const kviewerValue = fromStorageShape(def.fieldType, detail);
+      if (kviewerValue === void 0) continue;
+      formFields.applyFieldValueFromExternal(id, kviewerValue);
+      storage.setValue(id, toStorageShape(def.fieldType, kviewerValue));
+    }
+  };
+  eventBus.on("kviewer-updatefromsandbox", onUpdate);
+  return {
+    destroy() {
+      eventBus.off("kviewer-updatefromsandbox", onUpdate);
+      formFields.setValueWriteSink(null);
+    }
+  };
+}
+function toStorageShape(fieldType, value) {
+  if (fieldType === "checkbox") return { value: Boolean(value) };
+  if (fieldType === "radio") return { value: typeof value === "string" ? value : "" };
+  if (fieldType === "dropdown") {
+    return { value };
+  }
+  if (fieldType === "text") return { value: String(value ?? "") };
+  if (fieldType === "signature") return { value: String(value ?? "") };
+  return { value };
+}
+function fromStorageShape(fieldType, detail) {
+  const value = detail?.value;
+  if (value === void 0) return void 0;
+  if (fieldType === "checkbox") {
+    if (typeof value === "boolean") return value;
+    return value !== "Off" && value !== "" && value != null;
+  }
+  if (fieldType === "radio") {
+    if (typeof value === "string") return value;
+    if (value == null) return "";
+    return String(value);
+  }
+  if (fieldType === "dropdown") {
+    if (Array.isArray(value)) return value.map(String);
+    return value == null ? "" : String(value);
+  }
+  return value == null ? "" : String(value);
+}

package/dist/runtime/composables/useScriptingManager.d.ts

@@ -0,0 +1,65 @@
+import type { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist';
+import type { Ref } from 'vue';
+/** Minimal viewer surface PDFScriptingManager calls into. The official
+ *  PDFViewer is large; we mock the slice the manager actually touches
+ *  (verified in pdfjs-dist/web/pdf_viewer.mjs lines 7548-7691 and 7639). */
+export interface ScriptingViewerAdapter {
+    currentPageNumber: number;
+    pagesCount: number;
+    pagesPromise: Promise<void>;
+    nextPage: () => void;
+    previousPage: () => void;
+    currentScaleValue: number | string;
+    increaseScale: () => void;
+    decreaseScale: () => void;
+    spreadMode: number;
+    readonly isInPresentationMode: boolean;
+    readonly isChangingPresentationMode: boolean;
+    getPageView: (idx: number) => {
+        renderingState: number;
+        pdfPage: PDFPageProxy;
+    } | undefined;
+}
+export interface ScriptingManagerDeps {
+    viewerState: {
+        currentPage: Ref<number>;
+        totalPages: Ref<number>;
+        scale: Ref<number>;
+        setScale: (v: number) => void;
+        scrollToPage: (n: number) => void;
+    };
+    virtualization: {
+        isPageRendered: (pageNumber: number) => boolean;
+    };
+    proxyCache: {
+        getPageSync: (pageNumber: number) => PDFPageProxy | undefined;
+    };
+}
+export interface ScriptingManager {
+    /** Pump a user-interaction event into the sandbox for a given field. */
+    dispatchFieldEvent: (fieldId: string, name: 'Action' | 'Validate' | 'Focus' | 'Blur' | 'Mouse Up' | 'Mouse Down' | 'Mouse Enter' | 'Mouse Exit' | 'Keystroke', value: string | boolean | string[], extra?: Record<string, unknown>) => void;
+    /** Notify the sandbox that a page finished rendering, so any deferred
+     *  PageOpen action can fire (pdf_viewer.mjs:7441). */
+    notifyPageRendered: (pageNumber: number) => void;
+    /** Bind a document to the sandbox. Safe to call repeatedly — pass
+     *  null to detach (e.g. before swapping documents). */
+    setDocument: (pdfDoc: PDFDocumentProxy | null) => Promise<void>;
+    /** Tear down the manager, sandbox worker, and event listeners.
+     *  Idempotent. */
+    destroy: () => Promise<void>;
+    /** True once the sandbox has booted for the current document. */
+    isReady: () => boolean;
+}
+/** Construct the scripting manager. ONE instance per `<Viewer>` lifetime —
+ *  reuse `setDocument(null)` then `setDocument(newDoc)` across document
+ *  swaps. PDFScriptingManagerComponents attaches a window-level
+ *  `updatefromsandbox` listener in its constructor (pdf_viewer.mjs:7733)
+ *  with no removal path; constructing it per-document would leak. */
+export declare function createScriptingManager(deps: ScriptingManagerDeps): Promise<ScriptingManager>;
+/** Cast helper used by the bridge — keeps the eventBus access narrowly
+ *  typed without exporting an extra interface. */
+export declare function getEventBus(manager: ScriptingManager): {
+    on: (name: string, handler: (...args: unknown[]) => void) => void;
+    off: (name: string, handler: (...args: unknown[]) => void) => void;
+    dispatch: (name: string, payload: unknown) => void;
+};

package/dist/runtime/composables/useScriptingManager.js

@@ -0,0 +1,123 @@
+export async function createScriptingManager(deps) {
+  const pdfViewer = await import("pdfjs-dist/web/pdf_viewer.mjs");
+  const { PDFScriptingManager, EventBus, RenderingStates } = pdfViewer;
+  const eventBus = new EventBus();
+  const onSandboxWindowEvent = (event) => {
+    const d = event.detail ?? {};
+    eventBus.dispatch("kviewer-updatefromsandbox", {
+      source: window,
+      detail: {
+        ...d,
+        // Re-attach id and siblings explicitly (spread preserves them now,
+        // but is defensive against future mutations between our snapshot
+        // and the bridge's handler).
+        id: d.id,
+        siblings: d.siblings
+      }
+    });
+  };
+  window.addEventListener("updatefromsandbox", onSandboxWindowEvent);
+  const sandboxBundleSrc = new URL("/_kviewer/pdfjs/pdf.sandbox.mjs", window.location.origin).href;
+  const adapter = {
+    get currentPageNumber() {
+      return deps.viewerState.currentPage.value;
+    },
+    set currentPageNumber(n) {
+      const clamped = Math.min(Math.max(1, n), deps.viewerState.totalPages.value);
+      deps.viewerState.scrollToPage(clamped);
+    },
+    get pagesCount() {
+      return deps.viewerState.totalPages.value;
+    },
+    // Pages are virtualized — there's no global "all pages loaded" gate
+    // analogous to the official viewer's `pagesPromise`. Resolve immediately;
+    // the manager only awaits it before dispatching 'print'.
+    pagesPromise: Promise.resolve(),
+    nextPage() {
+      const cur = deps.viewerState.currentPage.value;
+      if (cur < deps.viewerState.totalPages.value) deps.viewerState.scrollToPage(cur + 1);
+    },
+    previousPage() {
+      const cur = deps.viewerState.currentPage.value;
+      if (cur > 1) deps.viewerState.scrollToPage(cur - 1);
+    },
+    get currentScaleValue() {
+      return deps.viewerState.scale.value;
+    },
+    set currentScaleValue(v) {
+      const n = typeof v === "number" ? v : Number.parseFloat(v);
+      if (Number.isFinite(n)) deps.viewerState.setScale(n);
+    },
+    increaseScale() {
+      deps.viewerState.setScale(deps.viewerState.scale.value * 1.1);
+    },
+    decreaseScale() {
+      deps.viewerState.setScale(deps.viewerState.scale.value / 1.1);
+    },
+    spreadMode: 0,
+    isInPresentationMode: false,
+    isChangingPresentationMode: false,
+    getPageView(idx) {
+      const pageNumber = idx + 1;
+      const pdfPage = deps.proxyCache.getPageSync(pageNumber);
+      if (!pdfPage) return void 0;
+      return {
+        pdfPage,
+        renderingState: deps.virtualization.isPageRendered(pageNumber) ? RenderingStates.FINISHED : 0
+      };
+    }
+  };
+  const manager = new PDFScriptingManager({
+    eventBus,
+    sandboxBundleSrc,
+    // Required: PDFScriptingManager passes the result into the sandbox's
+    // docInfo. The official viewer assembles a rich metadata blob; we
+    // provide the minimum the sandbox needs to boot. Fields are read by
+    // PDF scripts via `this.<key>` (e.g. `this.numPages`).
+    docProperties: async (pdfDoc) => ({
+      numPages: pdfDoc.numPages,
+      URL: "",
+      baseURL: "",
+      filesize: 0,
+      filename: "",
+      metadata: "",
+      authors: ""
+    })
+  });
+  manager.setViewer(adapter);
+  return {
+    dispatchFieldEvent(fieldId, name, value, extra) {
+      eventBus.dispatch("dispatcheventinsandbox", {
+        source: window,
+        detail: {
+          id: fieldId,
+          name,
+          value,
+          willCommit: true,
+          commitKey: 1,
+          ...extra
+        }
+      });
+    },
+    notifyPageRendered(pageNumber) {
+      eventBus.dispatch("pagerendered", { source: window, pageNumber });
+    },
+    async setDocument(pdfDoc) {
+      await manager.setDocument(pdfDoc);
+    },
+    async destroy() {
+      window.removeEventListener("updatefromsandbox", onSandboxWindowEvent);
+      await manager.setDocument(null);
+      const dp = manager.destroyPromise;
+      if (dp) await dp;
+    },
+    isReady() {
+      return manager.ready;
+    },
+    // Expose for the bridge.
+    ...{ _eventBus: eventBus }
+  };
+}
+export function getEventBus(manager) {
+  return manager._eventBus;
+}

package/dist/runtime/embed/bridge-client.d.ts

@@ -0,0 +1,58 @@
+import type { ExportPdfOptions } from '../annotation/pdf-export/export.js';
+import type { AddFormFieldPayload, FormFieldDefinition, FormFieldValue, IAnnotationStore } from '../annotation/engine/types.js';
+import { type EventName, type EventPayloads, type ImportAnnotationsMode } from './protocol.js';
+export interface KViewerEmbedClientOptions {
+    /**
+     * Origin of the iframe — used for postMessage `targetOrigin` AND as
+     * the inbound origin allowlist (responses/events from any other origin
+     * are dropped). Pass `'*'` for development only; production should pin
+     * a single origin.
+     */
+    iframeOrigin: string;
+    /**
+     * Optional override for the parent's window. Defaults to `window`.
+     * Useful for tests.
+     */
+    windowRef?: Window;
+}
+type EventHandler<E extends EventName> = (payload: EventPayloads[E]) => void;
+/**
+ * Parent-page client that drives a `<KViewer>` instance running inside
+ * an iframe. Wraps `postMessage` into a Promise-based RPC mirroring the
+ * viewer's exposed methods, and surfaces iframe-emitted events
+ * (`ready`, `formEditMode-changed`) via `on()`.
+ */
+export declare class KViewerEmbedClient {
+    private readonly iframe;
+    private readonly options;
+    private readonly win;
+    private readonly allowAny;
+    private readonly pending;
+    private readonly handlers;
+    private disposed;
+    constructor(iframe: HTMLIFrameElement, options: KViewerEmbedClientOptions);
+    /** Tear down the message listener and reject any in-flight requests. */
+    dispose(): void;
+    /** Subscribe to an iframe-emitted event. Returns an unsubscribe fn. */
+    on<E extends EventName>(name: E, handler: EventHandler<E>): () => void;
+    getAnnotations(): Promise<IAnnotationStore[]>;
+    importAnnotations(annotations: IAnnotationStore[], options?: {
+        mode?: ImportAnnotationsMode;
+    }): Promise<{
+        loaded: number;
+        skipped: number;
+    }>;
+    exportPdf(options?: ExportPdfOptions): Promise<Uint8Array>;
+    getFormFieldValues(): Promise<FormFieldValue[]>;
+    setFormFieldValue(fieldName: string, value: string | boolean | string[]): Promise<void>;
+    addFormField(payload: AddFormFieldPayload): Promise<FormFieldDefinition>;
+    updateFormField(id: string, patch: Partial<FormFieldDefinition>): Promise<void>;
+    removeFormField(id: string): Promise<void>;
+    getFormFields(): Promise<FormFieldDefinition[]>;
+    getFormEditMode(): Promise<boolean>;
+    setFormEditMode(enabled: boolean): Promise<void>;
+    toggleFormEditMode(): Promise<boolean>;
+    private call;
+    private handleMessage;
+}
+export {};

package/dist/runtime/embed/bridge-client.js

@@ -0,0 +1,143 @@
+import {
+  KVIEWER_EMBED_PROTOCOL_VERSION,
+  REQUEST_KIND,
+  isEvent,
+  isResponse
+} from "./protocol.js";
+let nextRequestId = 0;
+function makeRequestId() {
+  nextRequestId += 1;
+  return `kvr-${Date.now().toString(36)}-${nextRequestId.toString(36)}`;
+}
+export class KViewerEmbedClient {
+  iframe;
+  options;
+  win;
+  allowAny;
+  pending = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  disposed = false;
+  constructor(iframe, options) {
+    this.iframe = iframe;
+    this.options = options;
+    this.allowAny = options.iframeOrigin === "*";
+    const win = options.windowRef ?? (typeof window !== "undefined" ? window : void 0);
+    if (!win) {
+      throw new Error("KViewerEmbedClient requires a window (browser environment)");
+    }
+    this.win = win;
+    this.win.addEventListener("message", this.handleMessage);
+  }
+  /** Tear down the message listener and reject any in-flight requests. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.win.removeEventListener("message", this.handleMessage);
+    const err = new Error("KViewerEmbedClient was disposed");
+    for (const { reject } of this.pending.values()) reject(err);
+    this.pending.clear();
+    this.handlers.clear();
+  }
+  /** Subscribe to an iframe-emitted event. Returns an unsubscribe fn. */
+  on(name, handler) {
+    let set = this.handlers.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(name, set);
+    }
+    set.add(handler);
+    return () => {
+      set?.delete(handler);
+    };
+  }
+  // ── method mirrors ─────────────────────────────────────────────────────
+  getAnnotations() {
+    return this.call("getAnnotations");
+  }
+  importAnnotations(annotations, options) {
+    return this.call("importAnnotations", annotations, options);
+  }
+  exportPdf(options) {
+    return this.call("exportPdf", options);
+  }
+  getFormFieldValues() {
+    return this.call("getFormFieldValues");
+  }
+  setFormFieldValue(fieldName, value) {
+    return this.call("setFormFieldValue", fieldName, value);
+  }
+  addFormField(payload) {
+    return this.call("addFormField", payload);
+  }
+  updateFormField(id, patch) {
+    return this.call("updateFormField", id, patch);
+  }
+  removeFormField(id) {
+    return this.call("removeFormField", id);
+  }
+  getFormFields() {
+    return this.call("getFormFields");
+  }
+  getFormEditMode() {
+    return this.call("getFormEditMode");
+  }
+  setFormEditMode(enabled) {
+    return this.call("setFormEditMode", enabled);
+  }
+  toggleFormEditMode() {
+    return this.call("toggleFormEditMode");
+  }
+  // ── internals ──────────────────────────────────────────────────────────
+  call(method, ...args) {
+    if (this.disposed) {
+      return Promise.reject(new Error("KViewerEmbedClient was disposed"));
+    }
+    const target = this.iframe.contentWindow;
+    if (!target) {
+      return Promise.reject(new Error("iframe has no contentWindow"));
+    }
+    const id = makeRequestId();
+    const message = {
+      kind: REQUEST_KIND,
+      v: KVIEWER_EMBED_PROTOCOL_VERSION,
+      id,
+      method,
+      args
+    };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, {
+        resolve,
+        reject
+      });
+      target.postMessage(message, this.options.iframeOrigin);
+    });
+  }
+  handleMessage = (event) => {
+    if (!this.allowAny && event.origin !== this.options.iframeOrigin) return;
+    if (event.source !== this.iframe.contentWindow) return;
+    if (isResponse(event.data)) {
+      const pending = this.pending.get(event.data.id);
+      if (!pending) return;
+      this.pending.delete(event.data.id);
+      if (event.data.ok) {
+        pending.resolve(event.data.result);
+      } else {
+        const err = new Error(event.data.error.message);
+        if (event.data.error.name) err.name = event.data.error.name;
+        pending.reject(err);
+      }
+      return;
+    }
+    if (isEvent(event.data)) {
+      const set = this.handlers.get(event.data.name);
+      if (!set) return;
+      for (const handler of set) {
+        try {
+          handler(event.data.payload);
+        } catch (err) {
+          console.error("[KViewerEmbedClient] event handler threw:", err);
+        }
+      }
+    }
+  };
+}

package/dist/runtime/embed/bridge-host.d.ts

@@ -0,0 +1,59 @@
+import { type Ref } from 'vue';
+import type { ExportPdfOptions } from '../annotation/pdf-export/export.js';
+import type { AddFormFieldPayload, FormFieldDefinition, FormFieldValue, IAnnotationStore } from '../annotation/engine/types.js';
+import { type MethodName } from './protocol.js';
+/**
+ * Surface the bridge calls on the KViewer template ref. Mirrors the
+ * methods defined in `defineExpose` inside Viewer.vue. Kept as a
+ * structural type so a real `<KViewer>` ref satisfies it without any
+ * extra wiring at the call site.
+ */
+export interface KViewerApi {
+    getAnnotations: () => IAnnotationStore[];
+    importAnnotations: (annotations: IAnnotationStore[], options?: {
+        mode?: 'replace' | 'merge';
+    }) => Promise<{
+        loaded: number;
+        skipped: number;
+    }>;
+    exportPdf: (options?: ExportPdfOptions) => Promise<Uint8Array>;
+    getFormFieldValues: () => FormFieldValue[];
+    setFormFieldValue: (fieldName: string, value: string | boolean | string[]) => void;
+    addFormField: (payload: AddFormFieldPayload) => FormFieldDefinition;
+    updateFormField: (id: string, patch: Partial<FormFieldDefinition>) => void;
+    removeFormField: (id: string) => void;
+    getFormFields: () => FormFieldDefinition[];
+    formEditMode: Ref<boolean>;
+    setFormEditMode: (enabled: boolean) => void;
+    toggleFormEditMode: () => boolean;
+}
+export interface KViewerEmbedBridgeOptions {
+    /**
+     * Origin of the parent window that hosts this iframe. Used both as
+     * the inbound origin allowlist (anything else is dropped) and as the
+     * `targetOrigin` for outbound messages.
+     *
+     * Pass `'*'` to allow any origin. Demo / development only — there is
+     * no origin verification in that mode and `postMessage` will broadcast
+     * to whatever window happens to be the parent.
+     */
+    parentOrigin: string;
+    /**
+     * Optional override for the window the host listens on. Defaults to
+     * `window`. Useful for tests.
+     */
+    windowRef?: Window;
+    /**
+     * Optional override for the parent window receiver. Defaults to
+     * `window.parent`. The bridge falls back to the request's
+     * `event.source` for replies, so this is only needed for the unsolicited
+     * `ready` and `formEditMode-changed` events.
+     */
+    parentWindow?: Window;
+}
+interface BridgeHandle {
+    /** Manually tear down listeners. Called automatically on scope dispose. */
+    unmount: () => void;
+}
+export declare function useKViewerEmbedBridge(viewerRef: Ref<KViewerApi | null | undefined>, options: KViewerEmbedBridgeOptions): BridgeHandle;
+export type { MethodName };

package/dist/runtime/embed/bridge-host.js

@@ -0,0 +1,136 @@
+import { onScopeDispose, watch } from "vue";
+import {
+  EVENT_KIND,
+  KVIEWER_EMBED_PROTOCOL_VERSION,
+  RESPONSE_KIND,
+  isRequest
+} from "./protocol.js";
+export function useKViewerEmbedBridge(viewerRef, options) {
+  const allowAny = options.parentOrigin === "*";
+  const winMaybe = options.windowRef ?? (typeof window !== "undefined" ? window : void 0);
+  if (!winMaybe) {
+    return { unmount: () => {
+    } };
+  }
+  const win = winMaybe;
+  const parent = options.parentWindow ?? win.parent;
+  function originAllowed(origin) {
+    return allowAny || origin === options.parentOrigin;
+  }
+  function postEvent(name, payload) {
+    if (!parent || parent === win) return;
+    const message = {
+      kind: EVENT_KIND,
+      v: KVIEWER_EMBED_PROTOCOL_VERSION,
+      name,
+      payload
+    };
+    parent.postMessage(message, options.parentOrigin);
+  }
+  async function dispatch(req) {
+    const viewer = viewerRef.value;
+    if (!viewer) {
+      throw new Error("KViewer ref is not yet available");
+    }
+    switch (req.method) {
+      case "getAnnotations":
+        return viewer.getAnnotations();
+      case "importAnnotations": {
+        const [annotations, opts] = req.args;
+        return viewer.importAnnotations(annotations, opts);
+      }
+      case "exportPdf": {
+        const [opts] = req.args;
+        return viewer.exportPdf(opts);
+      }
+      case "getFormFieldValues":
+        return viewer.getFormFieldValues();
+      case "setFormFieldValue": {
+        const [name, value] = req.args;
+        viewer.setFormFieldValue(name, value);
+        return void 0;
+      }
+      case "addFormField": {
+        const [payload] = req.args;
+        return viewer.addFormField(payload);
+      }
+      case "updateFormField": {
+        const [id, patch] = req.args;
+        viewer.updateFormField(id, patch);
+        return void 0;
+      }
+      case "removeFormField": {
+        const [id] = req.args;
+        viewer.removeFormField(id);
+        return void 0;
+      }
+      case "getFormFields":
+        return viewer.getFormFields();
+      case "getFormEditMode":
+        return viewer.formEditMode.value;
+      case "setFormEditMode": {
+        const [enabled] = req.args;
+        viewer.setFormEditMode(enabled);
+        return void 0;
+      }
+      case "toggleFormEditMode":
+        return viewer.toggleFormEditMode();
+      default:
+        throw new Error(`Unknown KViewer embed method: ${req.method}`);
+    }
+  }
+  async function handleMessage(event) {
+    if (!originAllowed(event.origin)) return;
+    if (!isRequest(event.data)) return;
+    const req = event.data;
+    let reply;
+    try {
+      const result = await dispatch(req);
+      reply = {
+        kind: RESPONSE_KIND,
+        v: KVIEWER_EMBED_PROTOCOL_VERSION,
+        id: req.id,
+        ok: true,
+        result
+      };
+    } catch (err) {
+      reply = {
+        kind: RESPONSE_KIND,
+        v: KVIEWER_EMBED_PROTOCOL_VERSION,
+        id: req.id,
+        ok: false,
+        error: {
+          message: err instanceof Error ? err.message : String(err),
+          name: err instanceof Error ? err.name : void 0
+        }
+      };
+    }
+    const target = event.source ?? parent;
+    if (!target) return;
+    target.postMessage(reply, event.origin === "" ? options.parentOrigin : event.origin);
+  }
+  win.addEventListener("message", handleMessage);
+  let stopFormEditWatch = null;
+  const stopViewerWatch = watch(
+    viewerRef,
+    (viewer) => {
+      stopFormEditWatch?.();
+      stopFormEditWatch = null;
+      if (!viewer) return;
+      postEvent("ready", { protocolVersion: KVIEWER_EMBED_PROTOCOL_VERSION });
+      stopFormEditWatch = watch(
+        viewer.formEditMode,
+        (enabled) => postEvent("formEditMode-changed", { enabled })
+      );
+    },
+    { immediate: true }
+  );
+  function unmount() {
+    win.removeEventListener("message", handleMessage);
+    stopViewerWatch();
+    stopFormEditWatch?.();
+    stopFormEditWatch = null;
+  }
+  onScopeDispose(unmount);
+  return { unmount };
+}