@embedpdf/core 1.4.1 → 2.0.0-next.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Rotation, transformSize, NoopLogger } from "@embedpdf/models";
+import { Rotation, NoopLogger } from "@embedpdf/models";
 class DependencyResolver {
   constructor() {
     this.dependencyGraph = /* @__PURE__ */ new Map();
@@ -161,48 +161,103 @@ class PluginStore {
     });
   }
 }
-const LOAD_DOCUMENT = "LOAD_DOCUMENT";
+const START_LOADING_DOCUMENT = "START_LOADING_DOCUMENT";
+const UPDATE_DOCUMENT_LOADING_PROGRESS = "UPDATE_DOCUMENT_LOADING_PROGRESS";
+const SET_DOCUMENT_LOADED = "SET_DOCUMENT_LOADED";
+const SET_DOCUMENT_ERROR = "SET_DOCUMENT_ERROR";
+const RETRY_LOADING_DOCUMENT = "RETRY_LOADING_DOCUMENT";
+const CLOSE_DOCUMENT = "CLOSE_DOCUMENT";
+const SET_ACTIVE_DOCUMENT = "SET_ACTIVE_DOCUMENT";
+const REORDER_DOCUMENTS = "REORDER_DOCUMENTS";
+const MOVE_DOCUMENT = "MOVE_DOCUMENT";
 const REFRESH_DOCUMENT = "REFRESH_DOCUMENT";
 const REFRESH_PAGES = "REFRESH_PAGES";
-const SET_DOCUMENT = "SET_DOCUMENT";
-const SET_DOCUMENT_ERROR = "SET_DOCUMENT_ERROR";
+const SET_PAGES = "SET_PAGES";
 const SET_SCALE = "SET_SCALE";
 const SET_ROTATION = "SET_ROTATION";
-const SET_PAGES = "SET_PAGES";
+const SET_DEFAULT_SCALE = "SET_DEFAULT_SCALE";
+const SET_DEFAULT_ROTATION = "SET_DEFAULT_ROTATION";
 const CORE_ACTION_TYPES = [
-  LOAD_DOCUMENT,
-  REFRESH_DOCUMENT,
-  SET_DOCUMENT,
+  START_LOADING_DOCUMENT,
+  UPDATE_DOCUMENT_LOADING_PROGRESS,
+  SET_DOCUMENT_LOADED,
+  CLOSE_DOCUMENT,
+  SET_ACTIVE_DOCUMENT,
   SET_DOCUMENT_ERROR,
+  RETRY_LOADING_DOCUMENT,
+  REFRESH_DOCUMENT,
+  REFRESH_PAGES,
+  SET_PAGES,
   SET_SCALE,
   SET_ROTATION,
-  SET_PAGES
+  SET_DEFAULT_SCALE,
+  SET_DEFAULT_ROTATION,
+  REORDER_DOCUMENTS,
+  MOVE_DOCUMENT
 ];
-const loadDocument = () => ({ type: LOAD_DOCUMENT });
-const refreshDocument = (document) => ({
+const startLoadingDocument = (documentId, name, scale, rotation, passwordProvided, autoActivate) => ({
+  type: START_LOADING_DOCUMENT,
+  payload: { documentId, name, scale, rotation, passwordProvided, autoActivate }
+});
+const updateDocumentLoadingProgress = (documentId, progress) => ({
+  type: UPDATE_DOCUMENT_LOADING_PROGRESS,
+  payload: { documentId, progress }
+});
+const setDocumentLoaded = (documentId, document) => ({
+  type: SET_DOCUMENT_LOADED,
+  payload: { documentId, document }
+});
+const setDocumentError = (documentId, error, errorCode, errorDetails) => ({
+  type: SET_DOCUMENT_ERROR,
+  payload: { documentId, error, errorCode, errorDetails }
+});
+const retryLoadingDocument = (documentId, passwordProvided) => ({
+  type: RETRY_LOADING_DOCUMENT,
+  payload: { documentId, passwordProvided }
+});
+const closeDocument = (documentId, nextActiveDocumentId) => ({
+  type: CLOSE_DOCUMENT,
+  payload: { documentId, nextActiveDocumentId }
+});
+const setActiveDocument = (documentId) => ({
+  type: SET_ACTIVE_DOCUMENT,
+  payload: documentId
+});
+const refreshDocument = (documentId, document) => ({
   type: REFRESH_DOCUMENT,
-  payload: document
+  payload: { documentId, document }
 });
-const refreshPages = (pages) => ({
+const refreshPages = (documentId, pageIndexes) => ({
   type: REFRESH_PAGES,
-  payload: pages
+  payload: { documentId, pageIndexes }
 });
-const setDocument = (document) => ({
-  type: SET_DOCUMENT,
-  payload: document
+const setPages = (documentId, pages) => ({
+  type: SET_PAGES,
+  payload: { documentId, pages }
 });
-const setDocumentError = (error) => ({
-  type: SET_DOCUMENT_ERROR,
-  payload: error
+const setScale = (scale, documentId) => ({
+  type: SET_SCALE,
+  payload: { scale, documentId }
 });
-const setScale = (scale) => ({ type: SET_SCALE, payload: scale });
-const setRotation = (rotation) => ({
+const setRotation = (rotation, documentId) => ({
   type: SET_ROTATION,
+  payload: { rotation, documentId }
+});
+const setDefaultScale = (scale) => ({
+  type: SET_DEFAULT_SCALE,
+  payload: scale
+});
+const setDefaultRotation = (rotation) => ({
+  type: SET_DEFAULT_ROTATION,
   payload: rotation
 });
-const setPages = (pages) => ({
-  type: SET_PAGES,
-  payload: pages
+const reorderDocuments = (order) => ({
+  type: REORDER_DOCUMENTS,
+  payload: order
+});
+const moveDocument = (documentId, toIndex) => ({
+  type: MOVE_DOCUMENT,
+  payload: { documentId, toIndex }
 });
 class Store {
   /**
@@ -460,66 +515,252 @@ class Store {
   }
 }
 const initialCoreState = (config) => ({
-  scale: (config == null ? void 0 : config.scale) ?? 1,
-  rotation: (config == null ? void 0 : config.rotation) ?? Rotation.Degree0,
-  document: null,
-  pages: [],
-  loading: false,
-  error: null
+  documents: {},
+  documentOrder: [],
+  activeDocumentId: null,
+  defaultScale: (config == null ? void 0 : config.defaultScale) ?? 1,
+  defaultRotation: (config == null ? void 0 : config.defaultRotation) ?? Rotation.Degree0
 });
-const getPagesWithRotatedSize = (state) => {
-  return state.pages.map(
-    (page) => page.map((p) => ({
-      ...p,
-      rotatedSize: transformSize(p.size, state.rotation, 1)
-    }))
-  );
+const getActiveDocumentState = (state) => {
+  if (!state.activeDocumentId) return null;
+  return state.documents[state.activeDocumentId] ?? null;
+};
+const getDocumentState = (state, documentId) => {
+  return state.documents[documentId] ?? null;
+};
+const getDocumentIds = (state) => {
+  return Object.keys(state.documents);
+};
+const isDocumentLoaded = (state, documentId) => {
+  return !!state.documents[documentId];
+};
+const getDocumentCount = (state) => {
+  return Object.keys(state.documents).length;
 };
+function calculateNextActiveDocument(state, closingDocumentId, explicitNext) {
+  const currentActiveId = state.activeDocumentId;
+  if (currentActiveId !== closingDocumentId) {
+    return currentActiveId;
+  }
+  if (explicitNext !== void 0) {
+    return explicitNext && state.documents[explicitNext] ? explicitNext : null;
+  }
+  const closingIndex = state.documentOrder.indexOf(closingDocumentId);
+  if (closingIndex === -1) {
+    return null;
+  }
+  if (closingIndex > 0) {
+    return state.documentOrder[closingIndex - 1];
+  }
+  if (closingIndex < state.documentOrder.length - 1) {
+    return state.documentOrder[closingIndex + 1];
+  }
+  return null;
+}
+function moveDocumentInOrder(currentOrder, documentId, toIndex) {
+  const fromIndex = currentOrder.indexOf(documentId);
+  if (fromIndex === -1) return null;
+  if (toIndex < 0 || toIndex >= currentOrder.length) return null;
+  if (fromIndex === toIndex) return null;
+  const newOrder = [...currentOrder];
+  newOrder.splice(fromIndex, 1);
+  newOrder.splice(toIndex, 0, documentId);
+  return newOrder;
+}
 const coreReducer = (state, action) => {
   switch (action.type) {
-    case LOAD_DOCUMENT:
+    case START_LOADING_DOCUMENT: {
+      const {
+        documentId,
+        name,
+        scale,
+        rotation,
+        passwordProvided,
+        autoActivate = true
+      } = action.payload;
+      const newDocState = {
+        id: documentId,
+        name,
+        status: "loading",
+        loadingProgress: 0,
+        error: null,
+        document: null,
+        scale: scale ?? state.defaultScale,
+        rotation: rotation ?? state.defaultRotation,
+        passwordProvided: passwordProvided ?? false,
+        pageRefreshVersions: {},
+        loadStartedAt: Date.now()
+      };
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: newDocState
+        },
+        documentOrder: [...state.documentOrder, documentId],
+        // Only activate if autoActivate is true (default), or if no document is currently active
+        activeDocumentId: autoActivate || !state.activeDocumentId ? documentId : state.activeDocumentId
+      };
+    }
+    case UPDATE_DOCUMENT_LOADING_PROGRESS: {
+      const { documentId, progress } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState || docState.status !== "loading") return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            loadingProgress: progress
+          }
+        }
+      };
+    }
+    case SET_DOCUMENT_LOADED: {
+      const { documentId, document } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            status: "loaded",
+            document,
+            error: null,
+            errorCode: void 0,
+            errorDetails: void 0,
+            passwordProvided: void 0,
+            loadedAt: Date.now()
+          }
+        }
+      };
+    }
+    case SET_DOCUMENT_ERROR: {
+      const { documentId, error, errorCode, errorDetails } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return {
+        ...state,
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            status: "error",
+            error,
+            errorCode,
+            errorDetails
+          }
+        }
+      };
+    }
+    case RETRY_LOADING_DOCUMENT: {
+      const { documentId, passwordProvided } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState || docState.status !== "error") return state;
       return {
         ...state,
-        loading: true,
-        error: null
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            status: "loading",
+            loadingProgress: 0,
+            error: null,
+            errorCode: void 0,
+            errorDetails: void 0,
+            passwordProvided: passwordProvided ?? false,
+            loadStartedAt: Date.now()
+          }
+        }
       };
-    case SET_DOCUMENT:
+    }
+    case CLOSE_DOCUMENT: {
+      const { documentId, nextActiveDocumentId } = action.payload;
+      const { [documentId]: removed, ...remainingDocs } = state.documents;
+      return {
+        ...state,
+        documents: remainingDocs,
+        documentOrder: state.documentOrder.filter((id) => id !== documentId),
+        activeDocumentId: calculateNextActiveDocument(state, documentId, nextActiveDocumentId)
+      };
+    }
+    case MOVE_DOCUMENT: {
+      const { documentId, toIndex } = action.payload;
+      const newOrder = moveDocumentInOrder(state.documentOrder, documentId, toIndex);
+      if (!newOrder) return state;
       return {
         ...state,
-        document: action.payload,
-        pages: action.payload.pages.map((page) => [page]),
-        loading: false,
-        error: null
+        documentOrder: newOrder
       };
-    case REFRESH_DOCUMENT:
+    }
+    case REORDER_DOCUMENTS: {
       return {
         ...state,
-        document: action.payload,
-        pages: action.payload.pages.map((page) => [page]),
-        loading: false,
-        error: null
+        documentOrder: action.payload
       };
-    case SET_ROTATION:
+    }
+    case SET_ACTIVE_DOCUMENT: {
       return {
         ...state,
-        rotation: action.payload
+        activeDocumentId: action.payload
       };
-    case SET_PAGES:
+    }
+    case SET_SCALE: {
+      const { scale, documentId } = action.payload;
+      const targetId = documentId ?? state.activeDocumentId;
+      if (!targetId) return state;
+      const docState = state.documents[targetId];
+      if (!docState) return state;
       return {
         ...state,
-        pages: action.payload
+        documents: {
+          ...state.documents,
+          [targetId]: {
+            ...docState,
+            scale
+          }
+        }
       };
-    case SET_DOCUMENT_ERROR:
+    }
+    case SET_ROTATION: {
+      const { rotation, documentId } = action.payload;
+      const targetId = documentId ?? state.activeDocumentId;
+      if (!targetId) return state;
+      const docState = state.documents[targetId];
+      if (!docState) return state;
       return {
         ...state,
-        loading: false,
-        error: action.payload
+        documents: {
+          ...state.documents,
+          [targetId]: {
+            ...docState,
+            rotation
+          }
+        }
       };
-    case SET_SCALE:
+    }
+    case REFRESH_PAGES: {
+      const { documentId, pageIndexes } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      const newVersions = { ...docState.pageRefreshVersions };
+      for (const pageIndex of pageIndexes) {
+        newVersions[pageIndex] = (newVersions[pageIndex] || 0) + 1;
+      }
       return {
         ...state,
-        scale: action.payload
+        documents: {
+          ...state.documents,
+          [documentId]: {
+            ...docState,
+            pageRefreshVersions: newVersions
+          }
+        }
       };
+    }
     default:
       return state;
   }
@@ -633,20 +874,15 @@ class PluginRegistry {
       return this.initPromise;
     }
     this.initPromise = (async () => {
-      var _a;
       if (this.initialized) {
         throw new PluginRegistrationError("Registry is already initialized");
       }
       this.isInitializing = true;
       try {
         await this.ensureEngineInitialized();
-        if (this.destroyed) {
-          return;
-        }
+        if (this.destroyed) return;
         while (this.pendingRegistrations.length > 0) {
-          if (this.destroyed) {
-            return;
-          }
+          if (this.destroyed) return;
           this.processingRegistrations = [...this.pendingRegistrations];
           this.pendingRegistrations = [];
           for (const reg of this.processingRegistrations) {
@@ -656,24 +892,23 @@ class PluginRegistry {
               const provider = this.processingRegistrations.find(
                 (r) => r.package.manifest.provides.includes(cap)
               );
-              if (provider) dependsOn.add(provider.package.manifest.id);
+              if (provider) {
+                dependsOn.add(provider.package.manifest.id);
+              }
             }
             this.resolver.addNode(reg.package.manifest.id, [...dependsOn]);
           }
           const loadOrder = this.resolver.resolveLoadOrder();
           for (const id of loadOrder) {
             const reg = this.processingRegistrations.find((r) => r.package.manifest.id === id);
-            await this.initializePlugin(reg.package.manifest, reg.package.create, reg.config);
+            this.instantiatePlugin(reg.package.manifest, reg.package.create, reg.config);
+          }
+          for (const id of loadOrder) {
+            await this.runPluginInitialization(id);
           }
           this.processingRegistrations = [];
           this.resolver = new DependencyResolver();
         }
-        for (const plugin of this.plugins.values()) {
-          await ((_a = plugin.postInitialize) == null ? void 0 : _a.call(plugin).catch((e) => {
-            console.error(`Error in postInitialize for plugin ${plugin.id}`, e);
-            this.status.set(plugin.id, "error");
-          }));
-        }
         this.initialized = true;
       } catch (err) {
         if (err instanceof Error) {
@@ -689,9 +924,9 @@ class PluginRegistry {
     return this.initPromise;
   }
   /**
-   * Initialize a single plugin with all necessary checks
+   * Phase 2: Create instance and register capabilities
    */
-  async initializePlugin(manifest, packageCreator, config) {
+  instantiatePlugin(manifest, packageCreator, config) {
     const finalConfig = {
       ...manifest.defaultConfig,
       ...config
@@ -699,25 +934,6 @@ class PluginRegistry {
     this.validateConfig(manifest.id, finalConfig, manifest.defaultConfig);
     const plugin = packageCreator(this, finalConfig);
     this.validatePlugin(plugin);
-    for (const capability of manifest.requires) {
-      if (!this.capabilities.has(capability)) {
-        throw new PluginRegistrationError(
-          `Missing required capability: ${capability} for plugin ${manifest.id}`
-        );
-      }
-    }
-    for (const capability of manifest.optional) {
-      if (this.capabilities.has(capability)) {
-        this.logger.debug(
-          "PluginRegistry",
-          "OptionalCapability",
-          `Optional capability ${capability} is available for plugin ${manifest.id}`
-        );
-      }
-    }
-    this.logger.debug("PluginRegistry", "InitializePlugin", `Initializing plugin ${manifest.id}`, {
-      provides: manifest.provides
-    });
     for (const capability of manifest.provides) {
       if (this.capabilities.has(capability)) {
         throw new PluginRegistrationError(
@@ -730,26 +946,41 @@ class PluginRegistry {
     this.manifests.set(manifest.id, manifest);
     this.status.set(manifest.id, "registered");
     this.configurations.set(manifest.id, finalConfig);
+  }
+  /**
+   * Phase 3: Run the initialize method
+   */
+  async runPluginInitialization(pluginId) {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin) return;
+    const manifest = this.manifests.get(pluginId);
+    const config = this.configurations.get(pluginId);
+    for (const capability of manifest.requires) {
+      if (!this.capabilities.has(capability)) {
+        throw new PluginRegistrationError(
+          `Missing required capability: ${capability} for plugin ${pluginId}`
+        );
+      }
+    }
+    this.logger.debug("PluginRegistry", "InitializePlugin", `Initializing plugin ${pluginId}`);
     try {
       if (plugin.initialize) {
-        await plugin.initialize(finalConfig);
+        await plugin.initialize(config);
       }
-      this.status.set(manifest.id, "active");
+      this.status.set(pluginId, "active");
       this.logger.info(
         "PluginRegistry",
         "PluginInitialized",
-        `Plugin ${manifest.id} initialized successfully`
+        `Plugin ${pluginId} initialized successfully`
       );
     } catch (error) {
-      this.plugins.delete(manifest.id);
-      this.manifests.delete(manifest.id);
+      this.status.set(pluginId, "error");
       this.logger.error(
         "PluginRegistry",
         "InitializationFailed",
-        `Plugin ${manifest.id} initialization failed`,
-        { provides: manifest.provides, error }
+        `Plugin ${pluginId} initialization failed`,
+        { error }
       );
-      manifest.provides.forEach((cap) => this.capabilities.delete(cap));
       throw error;
     }
   }
@@ -957,6 +1188,11 @@ class BasePlugin {
     this.debouncedTimeouts = {};
     this.unsubscribeFromState = null;
     this.unsubscribeFromCoreStore = null;
+    this.unsubscribeFromStartLoadingDocument = null;
+    this.unsubscribeFromSetDocumentLoaded = null;
+    this.unsubscribeFromCloseDocument = null;
+    this.unsubscribeFromSetScale = null;
+    this.unsubscribeFromSetRotation = null;
     if (id !== this.constructor.id) {
       throw new Error(
         `Plugin ID mismatch: ${id} !== ${this.constructor.id}`
@@ -971,6 +1207,39 @@ class BasePlugin {
     });
     this.unsubscribeFromCoreStore = this.coreStore.subscribe((action, newState, oldState) => {
       this.onCoreStoreUpdated(oldState, newState);
+      if (newState.core.activeDocumentId !== oldState.core.activeDocumentId) {
+        this.onActiveDocumentChanged(
+          oldState.core.activeDocumentId,
+          newState.core.activeDocumentId
+        );
+      }
+    });
+    this.unsubscribeFromStartLoadingDocument = this.coreStore.onAction(
+      START_LOADING_DOCUMENT,
+      (action) => {
+        this.onDocumentLoadingStarted(action.payload.documentId);
+      }
+    );
+    this.unsubscribeFromSetDocumentLoaded = this.coreStore.onAction(
+      SET_DOCUMENT_LOADED,
+      (action) => {
+        this.onDocumentLoaded(action.payload.documentId);
+      }
+    );
+    this.unsubscribeFromCloseDocument = this.coreStore.onAction(CLOSE_DOCUMENT, (action) => {
+      this.onDocumentClosed(action.payload.documentId);
+    });
+    this.unsubscribeFromSetScale = this.coreStore.onAction(SET_SCALE, (action, state) => {
+      const targetId = action.payload.documentId ?? state.core.activeDocumentId;
+      if (targetId) {
+        this.onScaleChanged(targetId, action.payload.scale);
+      }
+    });
+    this.unsubscribeFromSetRotation = this.coreStore.onAction(SET_ROTATION, (action, state) => {
+      const targetId = action.payload.documentId ?? state.core.activeDocumentId;
+      if (targetId) {
+        this.onRotationChanged(targetId, action.payload.rotation);
+      }
     });
     this.readyPromise = new Promise((resolve) => {
       this.readyResolve = resolve;
@@ -1095,6 +1364,37 @@ class BasePlugin {
    */
   onCoreStoreUpdated(oldState, newState) {
   }
+  /**
+   * Called when a document is opened
+   * Override to initialize per-document state
+   * @param documentId The ID of the document that was opened
+   */
+  onDocumentLoadingStarted(documentId) {
+  }
+  /**
+   * Called when a document is loaded
+   * @param documentId The ID of the document that is loaded
+   */
+  onDocumentLoaded(documentId) {
+  }
+  /**
+   * Called when a document is closed
+   * Override to cleanup per-document state
+   * @param documentId The ID of the document that was closed
+   */
+  onDocumentClosed(documentId) {
+  }
+  /**
+   * Called when the active document changes
+   * @param previousId The ID of the previous active document
+   * @param currentId The ID of the new active document
+   */
+  onActiveDocumentChanged(previousId, currentId) {
+  }
+  onScaleChanged(documentId, scale) {
+  }
+  onRotationChanged(documentId, rotation) {
+  }
   /**
    * Cleanup method to be called when plugin is being destroyed
    */
@@ -1111,6 +1411,26 @@ class BasePlugin {
       this.unsubscribeFromCoreStore();
       this.unsubscribeFromCoreStore = null;
     }
+    if (this.unsubscribeFromStartLoadingDocument) {
+      this.unsubscribeFromStartLoadingDocument();
+      this.unsubscribeFromStartLoadingDocument = null;
+    }
+    if (this.unsubscribeFromSetDocumentLoaded) {
+      this.unsubscribeFromSetDocumentLoaded();
+      this.unsubscribeFromSetDocumentLoaded = null;
+    }
+    if (this.unsubscribeFromCloseDocument) {
+      this.unsubscribeFromCloseDocument();
+      this.unsubscribeFromCloseDocument = null;
+    }
+    if (this.unsubscribeFromSetScale) {
+      this.unsubscribeFromSetScale();
+      this.unsubscribeFromSetScale = null;
+    }
+    if (this.unsubscribeFromSetRotation) {
+      this.unsubscribeFromSetRotation();
+      this.unsubscribeFromSetRotation = null;
+    }
   }
   /**
    * Returns a promise that resolves when the plugin is ready
@@ -1132,6 +1452,45 @@ class BasePlugin {
       this.readyResolve = resolve;
     });
   }
+  /**
+   * Get the active document ID
+   * @throws Error if no active document exists
+   */
+  getActiveDocumentId() {
+    const id = this.coreState.core.activeDocumentId;
+    if (!id) {
+      throw new Error("No active document");
+    }
+    return id;
+  }
+  /**
+   * Get the active document ID or null if none exists
+   */
+  getActiveDocumentIdOrNull() {
+    return this.coreState.core.activeDocumentId;
+  }
+  /**
+   * Get core document state for a specific document
+   * @param documentId Document ID (optional, defaults to active document)
+   * @returns Document state or null if not found
+   */
+  getCoreDocument(documentId) {
+    const id = documentId ?? this.getActiveDocumentIdOrNull();
+    if (!id) return null;
+    return this.coreState.core.documents[id] ?? null;
+  }
+  /**
+   * Get core document state for a specific document
+   * @param documentId Document ID (optional, defaults to active document)
+   * @throws Error if document not found
+   */
+  getCoreDocumentOrThrow(documentId) {
+    const doc = this.getCoreDocument(documentId);
+    if (!doc) {
+      throw new Error(`Document not found: ${documentId ?? "active"}`);
+    }
+    return doc;
+  }
 }
 class EventControl {
   constructor(handler, options) {
@@ -1183,6 +1542,36 @@ class EventControl {
     }
   }
 }
+class KeyedEventControl {
+  constructor(handler, options) {
+    this.handler = handler;
+    this.options = options;
+    this.controls = /* @__PURE__ */ new Map();
+    this.handle = (data) => {
+      const key = String(this.options.keyExtractor(data));
+      let control = this.controls.get(key);
+      if (!control) {
+        control = new EventControl(this.handler, this.baseOptions);
+        this.controls.set(key, control);
+      }
+      control.handle(data);
+    };
+    this.baseOptions = {
+      mode: options.mode,
+      wait: options.wait,
+      ...options.mode === "throttle" && "throttleMode" in options ? { throttleMode: options.throttleMode } : {}
+    };
+  }
+  destroy() {
+    for (const control of this.controls.values()) {
+      control.destroy();
+    }
+    this.controls.clear();
+  }
+}
+function isKeyedOptions(options) {
+  return "keyExtractor" in options;
+}
 function clamp(value, min, max) {
   return value < min ? min : value > max ? max : value;
 }
@@ -1281,9 +1670,15 @@ function createBehaviorEmitter(initial, equality = arePropsEqual) {
     let destroy = () => {
     };
     if (options) {
-      const ctl = new EventControl(listener, options);
-      realListener = ctl.handle;
-      destroy = () => ctl.destroy();
+      if (isKeyedOptions(options)) {
+        const ctl = new KeyedEventControl(listener, options);
+        realListener = ctl.handle;
+        destroy = () => ctl.destroy();
+      } else {
+        const ctl = new EventControl(listener, options);
+        realListener = ctl.handle;
+        destroy = () => ctl.destroy();
+      }
       proxyMap.set(listener, { wrapped: realListener, destroy });
     }
     if (_value !== void 0) realListener(_value);
@@ -1344,6 +1739,155 @@ function createBehaviorEmitter(initial, equality = arePropsEqual) {
     }
   };
 }
+function createScopedEmitter(toGlobalEvent, options) {
+  const shouldCache = (options == null ? void 0 : options.cache) ?? true;
+  const equality = (options == null ? void 0 : options.equality) ?? arePropsEqual;
+  const scopeCaches = /* @__PURE__ */ new Map();
+  const scopeListeners = /* @__PURE__ */ new Map();
+  const scopeProxyMaps = /* @__PURE__ */ new Map();
+  const globalListeners = /* @__PURE__ */ new Set();
+  const globalProxyMap = /* @__PURE__ */ new Map();
+  const normalizeKey = (key) => String(key);
+  const getOrCreateListeners = (key) => {
+    let listeners = scopeListeners.get(key);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      scopeListeners.set(key, listeners);
+    }
+    return listeners;
+  };
+  const getOrCreateProxyMap = (key) => {
+    let proxyMap = scopeProxyMaps.get(key);
+    if (!proxyMap) {
+      proxyMap = /* @__PURE__ */ new Map();
+      scopeProxyMaps.set(key, proxyMap);
+    }
+    return proxyMap;
+  };
+  const onGlobal = (listener, options2) => {
+    let realListener = listener;
+    let destroy = () => {
+    };
+    if (options2) {
+      if (isKeyedOptions(options2)) {
+        const ctl = new KeyedEventControl(listener, options2);
+        realListener = ctl.handle;
+        destroy = () => ctl.destroy();
+      } else {
+        const ctl = new EventControl(listener, options2);
+        realListener = ctl.handle;
+        destroy = () => ctl.destroy();
+      }
+      globalProxyMap.set(listener, { wrapped: realListener, destroy });
+    }
+    globalListeners.add(realListener);
+    return () => {
+      globalListeners.delete(realListener);
+      destroy();
+      globalProxyMap.delete(listener);
+    };
+  };
+  return {
+    emit(key, data) {
+      const normalizedKey = normalizeKey(key);
+      if (shouldCache) {
+        const cached = scopeCaches.get(normalizedKey);
+        if (cached !== void 0 && equality(cached, data)) {
+          return;
+        }
+        scopeCaches.set(normalizedKey, data);
+      }
+      const listeners = scopeListeners.get(normalizedKey);
+      if (listeners) {
+        listeners.forEach((l) => l(data));
+      }
+      const globalEvent = toGlobalEvent(key, data);
+      globalListeners.forEach((l) => l(globalEvent));
+    },
+    forScope(key) {
+      const normalizedKey = normalizeKey(key);
+      return (listener, options2) => {
+        const listeners = getOrCreateListeners(normalizedKey);
+        const proxyMap = getOrCreateProxyMap(normalizedKey);
+        let realListener = listener;
+        let destroy = () => {
+        };
+        if (options2) {
+          if (isKeyedOptions(options2)) {
+            const ctl = new KeyedEventControl(listener, options2);
+            realListener = ctl.handle;
+            destroy = () => ctl.destroy();
+          } else {
+            const ctl = new EventControl(listener, options2);
+            realListener = ctl.handle;
+            destroy = () => ctl.destroy();
+          }
+          proxyMap.set(listener, { wrapped: realListener, destroy });
+        }
+        if (shouldCache) {
+          const cached = scopeCaches.get(normalizedKey);
+          if (cached !== void 0) {
+            realListener(cached);
+          }
+        }
+        listeners.add(realListener);
+        return () => {
+          listeners.delete(realListener);
+          destroy();
+          proxyMap.delete(listener);
+          if (listeners.size === 0) {
+            scopeListeners.delete(normalizedKey);
+          }
+          if (proxyMap.size === 0) {
+            scopeProxyMaps.delete(normalizedKey);
+          }
+        };
+      };
+    },
+    onGlobal,
+    getValue(key) {
+      return shouldCache ? scopeCaches.get(normalizeKey(key)) : void 0;
+    },
+    getScopes() {
+      if (shouldCache) {
+        return Array.from(scopeCaches.keys());
+      }
+      return Array.from(scopeListeners.keys());
+    },
+    clearScope(key) {
+      const normalizedKey = normalizeKey(key);
+      if (shouldCache) {
+        scopeCaches.delete(normalizedKey);
+      }
+      const listeners = scopeListeners.get(normalizedKey);
+      if (listeners) {
+        listeners.clear();
+        scopeListeners.delete(normalizedKey);
+      }
+      const proxyMap = scopeProxyMaps.get(normalizedKey);
+      if (proxyMap) {
+        proxyMap.forEach((p) => p.destroy());
+        proxyMap.clear();
+        scopeProxyMaps.delete(normalizedKey);
+      }
+    },
+    clear() {
+      if (shouldCache) {
+        scopeCaches.clear();
+      }
+      scopeListeners.forEach((set) => set.clear());
+      scopeListeners.clear();
+      scopeProxyMaps.forEach((map) => {
+        map.forEach((p) => p.destroy());
+        map.clear();
+      });
+      scopeProxyMaps.clear();
+      globalListeners.clear();
+      globalProxyMap.forEach((p) => p.destroy());
+      globalProxyMap.clear();
+    }
+  };
+}
 function enumEntries(record) {
   return Object.entries(record).map(([k, v]) => {
     const maybeNum = Number(k);
@@ -1376,13 +1920,15 @@ function createPluginPackage(basePackage) {
 }
 export {
   BasePlugin,
+  CLOSE_DOCUMENT,
   CORE_ACTION_TYPES,
   CapabilityConflictError,
   CapabilityNotFoundError,
   CircularDependencyError,
   DependencyResolver,
   EventControl,
-  LOAD_DOCUMENT,
+  KeyedEventControl,
+  MOVE_DOCUMENT,
   PluginConfigurationError,
   PluginInitializationError,
   PluginNotFoundError,
@@ -1391,28 +1937,49 @@ export {
   PluginRegistry,
   REFRESH_DOCUMENT,
   REFRESH_PAGES,
-  SET_DOCUMENT,
+  REORDER_DOCUMENTS,
+  RETRY_LOADING_DOCUMENT,
+  SET_ACTIVE_DOCUMENT,
+  SET_DEFAULT_ROTATION,
+  SET_DEFAULT_SCALE,
   SET_DOCUMENT_ERROR,
+  SET_DOCUMENT_LOADED,
   SET_PAGES,
   SET_ROTATION,
   SET_SCALE,
+  START_LOADING_DOCUMENT,
+  UPDATE_DOCUMENT_LOADING_PROGRESS,
   arePropsEqual,
   clamp,
+  closeDocument,
   createBehaviorEmitter,
   createEmitter,
   createPluginPackage,
   createPluginRegistration,
+  createScopedEmitter,
   enumEntries,
-  getPagesWithRotatedSize,
+  getActiveDocumentState,
+  getDocumentCount,
+  getDocumentIds,
+  getDocumentState,
   hasAutoMountElements,
   initialCoreState,
-  loadDocument,
+  isDocumentLoaded,
+  isKeyedOptions,
+  moveDocument,
   refreshDocument,
   refreshPages,
-  setDocument,
+  reorderDocuments,
+  retryLoadingDocument,
+  setActiveDocument,
+  setDefaultRotation,
+  setDefaultScale,
   setDocumentError,
+  setDocumentLoaded,
   setPages,
   setRotation,
-  setScale
+  setScale,
+  startLoadingDocument,
+  updateDocumentLoadingProgress
 };
 //# sourceMappingURL=index.js.map