@embedpdf/plugin-metadata 3.0.0-next.10 → 3.0.0-next.12

package/dist/contract-CqhcLHxo.cjs

@@ -0,0 +1,11 @@
+//#region src/types.ts
+const MetadataToken = (0, require("@embedpdf/core").createCapabilityToken)("metadata");
+//#endregion
+Object.defineProperty(exports, "MetadataToken", {
+	enumerable: true,
+	get: function() {
+		return MetadataToken;
+	}
+});
+
+//# sourceMappingURL=contract-CqhcLHxo.cjs.map

package/dist/contract-CqhcLHxo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-CqhcLHxo.cjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import { createCapabilityToken, type DocumentMetadata, type MetadataPatch } from '@embedpdf/core';\n\n/**\n * The document's Info-dict metadata, held as REACTIVE state — not a one-shot\n * read. It changes from local edits AND from other sessions (a remote edit\n * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to\n * the document event stream and keeps `current()` live. `update` writes a\n * three-state patch into the LAYER (like a page mutation), so a metadata edit\n * saves with the layer.\n */\nexport interface MetadataState {\n  /** Current metadata, or null until the first read resolves. */\n  metadata: DocumentMetadata | null;\n}\n\nexport type MetadataAction = { type: 'SET'; metadata: DocumentMetadata | null };\n\nexport interface MetadataCapability {\n  /**\n   * Whether this caller is authorized to edit the Info dict —\n   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their\n   * edit affordances on this; the engine independently enforces the same\n   * capability and throws `PermissionDenied` if a write slips through.\n   */\n  canEdit(): boolean;\n  /** Current metadata; null until the initial read lands. Reactive — reflects\n   *  own edits and remote (SSE) edits via the event stream. */\n  current(): DocumentMetadata | null;\n  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the\n   *  layer; state refreshes from the resulting `metadata.updated` event. */\n  update(patch: MetadataPatch): Promise<void>;\n  /** Force a re-read from the engine (rarely needed — the event stream keeps\n   *  state fresh). */\n  reload(): Promise<void>;\n}\n\nexport const MetadataToken = createCapabilityToken<MetadataCapability>('metadata');\n"],"mappings":";AAoCA,MAAa,iBAAA,2BAAA,CAAA,CAAA,sBAAA,CAA0D,UAAU"}

package/dist/contract-DXGV7Wpx.js

@@ -0,0 +1,7 @@
+import { createCapabilityToken } from "@embedpdf/core";
+//#region src/types.ts
+const MetadataToken = createCapabilityToken("metadata");
+//#endregion
+export { MetadataToken as t };
+
+//# sourceMappingURL=contract-DXGV7Wpx.js.map

package/dist/contract-DXGV7Wpx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-DXGV7Wpx.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["import { createCapabilityToken, type DocumentMetadata, type MetadataPatch } from '@embedpdf/core';\n\n/**\n * The document's Info-dict metadata, held as REACTIVE state — not a one-shot\n * read. It changes from local edits AND from other sessions (a remote edit\n * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to\n * the document event stream and keeps `current()` live. `update` writes a\n * three-state patch into the LAYER (like a page mutation), so a metadata edit\n * saves with the layer.\n */\nexport interface MetadataState {\n  /** Current metadata, or null until the first read resolves. */\n  metadata: DocumentMetadata | null;\n}\n\nexport type MetadataAction = { type: 'SET'; metadata: DocumentMetadata | null };\n\nexport interface MetadataCapability {\n  /**\n   * Whether this caller is authorized to edit the Info dict —\n   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their\n   * edit affordances on this; the engine independently enforces the same\n   * capability and throws `PermissionDenied` if a write slips through.\n   */\n  canEdit(): boolean;\n  /** Current metadata; null until the initial read lands. Reactive — reflects\n   *  own edits and remote (SSE) edits via the event stream. */\n  current(): DocumentMetadata | null;\n  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the\n   *  layer; state refreshes from the resulting `metadata.updated` event. */\n  update(patch: MetadataPatch): Promise<void>;\n  /** Force a re-read from the engine (rarely needed — the event stream keeps\n   *  state fresh). */\n  reload(): Promise<void>;\n}\n\nexport const MetadataToken = createCapabilityToken<MetadataCapability>('metadata');\n"],"mappings":";;AAoCA,MAAa,gBAAgB,sBAA0C,UAAU"}

package/dist/contract-Dk5SGhEP.d.cts

@@ -0,0 +1,40 @@
+import { DocumentMetadata, MetadataPatch } from "@embedpdf/core";
+//#region src/types.d.ts
+/**
+ * The document's Info-dict metadata, held as REACTIVE state — not a one-shot
+ * read. It changes from local edits AND from other sessions (a remote edit
+ * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to
+ * the document event stream and keeps `current()` live. `update` writes a
+ * three-state patch into the LAYER (like a page mutation), so a metadata edit
+ * saves with the layer.
+ */
+interface MetadataState {
+  /** Current metadata, or null until the first read resolves. */
+  metadata: DocumentMetadata | null;
+}
+type MetadataAction = {
+  type: 'SET';
+  metadata: DocumentMetadata | null;
+};
+interface MetadataCapability {
+  /**
+   * Whether this caller is authorized to edit the Info dict —
+   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their
+   * edit affordances on this; the engine independently enforces the same
+   * capability and throws `PermissionDenied` if a write slips through.
+   */
+  canEdit(): boolean;
+  /** Current metadata; null until the initial read lands. Reactive — reflects
+   *  own edits and remote (SSE) edits via the event stream. */
+  current(): DocumentMetadata | null;
+  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the
+   *  layer; state refreshes from the resulting `metadata.updated` event. */
+  update(patch: MetadataPatch): Promise<void>;
+  /** Force a re-read from the engine (rarely needed — the event stream keeps
+   *  state fresh). */
+  reload(): Promise<void>;
+}
+declare const MetadataToken: import("@embedpdf/core").CapabilityToken<MetadataCapability>;
+//#endregion
+export { MetadataToken as i, MetadataCapability as n, MetadataState as r, MetadataAction as t };
+//# sourceMappingURL=contract-Dk5SGhEP.d.cts.map

package/dist/contract-Dk5SGhEP.d.ts

@@ -0,0 +1,40 @@
+import { DocumentMetadata, MetadataPatch } from "@embedpdf/core";
+//#region src/types.d.ts
+/**
+ * The document's Info-dict metadata, held as REACTIVE state — not a one-shot
+ * read. It changes from local edits AND from other sessions (a remote edit
+ * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to
+ * the document event stream and keeps `current()` live. `update` writes a
+ * three-state patch into the LAYER (like a page mutation), so a metadata edit
+ * saves with the layer.
+ */
+interface MetadataState {
+  /** Current metadata, or null until the first read resolves. */
+  metadata: DocumentMetadata | null;
+}
+type MetadataAction = {
+  type: 'SET';
+  metadata: DocumentMetadata | null;
+};
+interface MetadataCapability {
+  /**
+   * Whether this caller is authorized to edit the Info dict —
+   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their
+   * edit affordances on this; the engine independently enforces the same
+   * capability and throws `PermissionDenied` if a write slips through.
+   */
+  canEdit(): boolean;
+  /** Current metadata; null until the initial read lands. Reactive — reflects
+   *  own edits and remote (SSE) edits via the event stream. */
+  current(): DocumentMetadata | null;
+  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the
+   *  layer; state refreshes from the resulting `metadata.updated` event. */
+  update(patch: MetadataPatch): Promise<void>;
+  /** Force a re-read from the engine (rarely needed — the event stream keeps
+   *  state fresh). */
+  reload(): Promise<void>;
+}
+declare const MetadataToken: import("@embedpdf/core").CapabilityToken<MetadataCapability>;
+//#endregion
+export { MetadataToken as i, MetadataCapability as n, MetadataState as r, MetadataAction as t };
+//# sourceMappingURL=contract-Dk5SGhEP.d.ts.map

package/dist/contract.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_contract = require("./contract-CqhcLHxo.cjs");
+exports.MetadataToken = require_contract.MetadataToken;

package/dist/contract.d.cts

@@ -0,0 +1,2 @@
+import { i as MetadataToken, n as MetadataCapability, r as MetadataState } from "./contract-Dk5SGhEP.cjs";
+export { type MetadataCapability, type MetadataState, MetadataToken };

package/dist/contract.d.ts

@@ -0,0 +1,2 @@
+import { i as MetadataToken, n as MetadataCapability, r as MetadataState } from "./contract-Dk5SGhEP.js";
+export { type MetadataCapability, type MetadataState, MetadataToken };

package/dist/contract.js

@@ -0,0 +1,2 @@
+import { t as MetadataToken } from "./contract-DXGV7Wpx.js";
+export { MetadataToken };

package/dist/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_contract = require("./contract-CqhcLHxo.cjs");
 let _embedpdf_core = require("@embedpdf/core");
 //#region src/capability.ts
 /**
@@ -79,9 +80,6 @@ const metadataReducer = (state, a) => a.type === "SET" ? {
 	metadata: a.metadata
 } : state;
 //#endregion
-//#region src/types.ts
-const MetadataToken = (0, _embedpdf_core.createCapabilityToken)("metadata");
-//#endregion
 //#region src/metadata.plugin.ts
 /**
 * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it
@@ -90,7 +88,7 @@ const MetadataToken = (0, _embedpdf_core.createCapabilityToken)("metadata");
 */
 const metadataPlugin = () => (0, _embedpdf_core.definePlugin)({
 	id: "metadata",
-	token: MetadataToken,
+	token: require_contract.MetadataToken,
 	scope: "document",
 	initialState: initialMetadataState,
 	reduce: metadataReducer,
@@ -98,7 +96,7 @@ const metadataPlugin = () => (0, _embedpdf_core.definePlugin)({
 	effects: registerMetadataEffects
 });
 //#endregion
-exports.MetadataToken = MetadataToken;
+exports.MetadataToken = require_contract.MetadataToken;
 exports.metadataPlugin = metadataPlugin;
 
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../src/capability.ts","../src/effects.ts","../src/reducer.ts","../src/types.ts","../src/metadata.plugin.ts"],"sourcesContent":["import type { PluginContext, DocCapability } from '@embedpdf/core';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Authorization for Info-dict writes. Maps to PDF bit 4 (MODIFY). The engine\n * ALSO enforces this — `metadata.update` throws `PermissionDenied` without it,\n * identically on local and cloud — so `canEdit()` is the UI mirror of a real\n * guard, not the guard itself. Typed as `DocCapability` so a typo is a compile\n * error.\n */\nconst METADATA_MODIFY_CAPABILITY: DocCapability = 'doc.metadata.modify';\n\n/**\n * Reads/writes the document's Info dict through the engine handle and keeps the\n * plugin's state in sync. The live-update wiring (own + remote events) lives in\n * the effect; this is the read/write surface.\n */\nexport function createMetadataCapability(\n  ctx: PluginContext<MetadataState, MetadataAction>,\n): MetadataCapability {\n  const requireDoc = () => {\n    const doc = ctx.doc;\n    if (!doc) throw new Error('[metadata] no document bound');\n    return doc;\n  };\n\n  return {\n    canEdit() {\n      // Wildcard-aware predicate (mirrors the engine's own enforcement),\n      // identical on both engines. NOT `effectiveScope.includes(...)` — that\n      // enumeration drops the `*` admin grant, so it would hide the UI on a\n      // default admin open even though the engine allows the edit.\n      return ctx.doc?.security.allows(METADATA_MODIFY_CAPABILITY) ?? false;\n    },\n\n    current: () => ctx.getState().metadata,\n\n    update: async (patch) => {\n      // The write also emits a `metadata.updated` event the effect catches, so\n      // this dispatch is just for an immediate, in-sync update (idempotent).\n      const result = await requireDoc().metadata.update(patch);\n      ctx.dispatch({ type: 'SET', metadata: result.metadata });\n    },\n\n    reload: async () => {\n      const metadata = await requireDoc().metadata.read();\n      ctx.dispatch({ type: 'SET', metadata });\n    },\n  };\n}\n","import type { DocumentEvent, EffectContext } from '@embedpdf/core';\nimport type { MetadataAction, MetadataState } from './types';\n\n/**\n * Makes metadata REACTIVE — the reason this is a plugin, not a kernel IO call.\n *\n *  1. Seed: read the Info dict once when the document opens.\n *  2. Live: subscribe to the document event stream. A `metadata.updated` event\n *     carries the full re-read metadata and fires for OWN edits AND for remote\n *     edits delivered over SSE (another session) — both just become `setState`.\n *\n * The handle's stream is synchronous fan-out, so this coexists with the kernel's\n * own subscription (page registry) on the same handle.\n */\nexport function registerMetadataEffects(ctx: EffectContext<MetadataState, MetadataAction>): void {\n  const doc = ctx.doc;\n  if (!doc) return;\n\n  // 1. seed\n  void doc.metadata.read().then(\n    (metadata) => ctx.dispatch({ type: 'SET', metadata }),\n    () => {}, // doc closed / read aborted — ignore\n  );\n\n  // 2. live updates (own edits + remote SSE edits)\n  const unsubscribe = doc.events.subscribe((event: DocumentEvent) => {\n    if (event.type === 'metadata.updated') {\n      ctx.dispatch({ type: 'SET', metadata: event.metadata });\n    }\n  });\n  ctx.cleanup(unsubscribe);\n}\n","import type { MetadataAction, MetadataState } from './types';\n\nexport const initialMetadataState = (): MetadataState => ({ metadata: null });\n\n/** Pure. The only transition: replace the metadata snapshot (from a read or an\n *  event). */\nexport const metadataReducer = (state: MetadataState, a: MetadataAction): MetadataState =>\n  a.type === 'SET' ? { ...state, metadata: a.metadata } : state;\n","import { createCapabilityToken, type DocumentMetadata, type MetadataPatch } from '@embedpdf/core';\n\n/**\n * The document's Info-dict metadata, held as REACTIVE state — not a one-shot\n * read. It changes from local edits AND from other sessions (a remote edit\n * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to\n * the document event stream and keeps `current()` live. `update` writes a\n * three-state patch into the LAYER (like a page mutation), so a metadata edit\n * saves with the layer.\n */\nexport interface MetadataState {\n  /** Current metadata, or null until the first read resolves. */\n  metadata: DocumentMetadata | null;\n}\n\nexport type MetadataAction = { type: 'SET'; metadata: DocumentMetadata | null };\n\nexport interface MetadataCapability {\n  /**\n   * Whether this caller is authorized to edit the Info dict —\n   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their\n   * edit affordances on this; the engine independently enforces the same\n   * capability and throws `PermissionDenied` if a write slips through.\n   */\n  canEdit(): boolean;\n  /** Current metadata; null until the initial read lands. Reactive — reflects\n   *  own edits and remote (SSE) edits via the event stream. */\n  current(): DocumentMetadata | null;\n  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the\n   *  layer; state refreshes from the resulting `metadata.updated` event. */\n  update(patch: MetadataPatch): Promise<void>;\n  /** Force a re-read from the engine (rarely needed — the event stream keeps\n   *  state fresh). */\n  reload(): Promise<void>;\n}\n\nexport const MetadataToken = createCapabilityToken<MetadataCapability>('metadata');\n","import { definePlugin } from '@embedpdf/core';\nimport { createMetadataCapability } from './capability';\nimport { registerMetadataEffects } from './effects';\nimport { initialMetadataState, metadataReducer } from './reducer';\nimport { MetadataToken } from './types';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it\n * from the engine and keeps it live off the document event stream (own + remote\n * SSE edits); the capability is the read/write surface.\n */\nexport const metadataPlugin = () =>\n  definePlugin<MetadataState, MetadataAction, MetadataCapability>({\n    id: 'metadata',\n    token: MetadataToken,\n    scope: 'document',\n    initialState: initialMetadataState,\n    reduce: metadataReducer,\n    capability: createMetadataCapability,\n    effects: registerMetadataEffects,\n  });\n"],"mappings":";;;;;;;;;;AAUA,MAAM,6BAA4C;;;;;;AAOlD,SAAgB,yBACd,KACoB;CACpB,MAAM,mBAAmB;EACvB,MAAM,MAAM,IAAI;EAChB,IAAI,CAAC,KAAK,MAAM,IAAI,MAAM,8BAA8B;EACxD,OAAO;CACT;CAEA,OAAO;EACL,UAAU;GAKR,OAAO,IAAI,KAAK,SAAS,OAAO,0BAA0B,KAAK;EACjE;EAEA,eAAe,IAAI,SAAS,CAAC,CAAC;EAE9B,QAAQ,OAAO,UAAU;GAGvB,MAAM,SAAS,MAAM,WAAW,CAAC,CAAC,SAAS,OAAO,KAAK;GACvD,IAAI,SAAS;IAAE,MAAM;IAAO,UAAU,OAAO;GAAS,CAAC;EACzD;EAEA,QAAQ,YAAY;GAClB,MAAM,WAAW,MAAM,WAAW,CAAC,CAAC,SAAS,KAAK;GAClD,IAAI,SAAS;IAAE,MAAM;IAAO;GAAS,CAAC;EACxC;CACF;AACF;;;;;;;;;;;;;;ACnCA,SAAgB,wBAAwB,KAAyD;CAC/F,MAAM,MAAM,IAAI;CAChB,IAAI,CAAC,KAAK;CAGV,IAAS,SAAS,KAAK,CAAC,CAAC,MACtB,aAAa,IAAI,SAAS;EAAE,MAAM;EAAO;CAAS,CAAC,SAC9C,CAAC,CACT;CAGA,MAAM,cAAc,IAAI,OAAO,WAAW,UAAyB;EACjE,IAAI,MAAM,SAAS,oBACjB,IAAI,SAAS;GAAE,MAAM;GAAO,UAAU,MAAM;EAAS,CAAC;CAE1D,CAAC;CACD,IAAI,QAAQ,WAAW;AACzB;;;AC7BA,MAAa,8BAA6C,EAAE,UAAU,KAAK;;;AAI3E,MAAa,mBAAmB,OAAsB,MACpD,EAAE,SAAS,QAAQ;CAAE,GAAG;CAAO,UAAU,EAAE;AAAS,IAAI;;;AC6B1D,MAAa,iBAAA,GAAA,eAAA,sBAAA,CAA0D,UAAU;;;;;;;;ACxBjF,MAAa,wBAAA,GAAA,eAAA,aAAA,CACqD;CAC9D,IAAI;CACJ,OAAO;CACP,OAAO;CACP,cAAc;CACd,QAAQ;CACR,YAAY;CACZ,SAAS;AACX,CAAC"}
+{"version":3,"file":"index.cjs","names":["MetadataToken"],"sources":["../src/capability.ts","../src/effects.ts","../src/reducer.ts","../src/metadata.plugin.ts"],"sourcesContent":["import type { PluginContext, DocCapability } from '@embedpdf/core';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Authorization for Info-dict writes. Maps to PDF bit 4 (MODIFY). The engine\n * ALSO enforces this — `metadata.update` throws `PermissionDenied` without it,\n * identically on local and cloud — so `canEdit()` is the UI mirror of a real\n * guard, not the guard itself. Typed as `DocCapability` so a typo is a compile\n * error.\n */\nconst METADATA_MODIFY_CAPABILITY: DocCapability = 'doc.metadata.modify';\n\n/**\n * Reads/writes the document's Info dict through the engine handle and keeps the\n * plugin's state in sync. The live-update wiring (own + remote events) lives in\n * the effect; this is the read/write surface.\n */\nexport function createMetadataCapability(\n  ctx: PluginContext<MetadataState, MetadataAction>,\n): MetadataCapability {\n  const requireDoc = () => {\n    const doc = ctx.doc;\n    if (!doc) throw new Error('[metadata] no document bound');\n    return doc;\n  };\n\n  return {\n    canEdit() {\n      // Wildcard-aware predicate (mirrors the engine's own enforcement),\n      // identical on both engines. NOT `effectiveScope.includes(...)` — that\n      // enumeration drops the `*` admin grant, so it would hide the UI on a\n      // default admin open even though the engine allows the edit.\n      return ctx.doc?.security.allows(METADATA_MODIFY_CAPABILITY) ?? false;\n    },\n\n    current: () => ctx.getState().metadata,\n\n    update: async (patch) => {\n      // The write also emits a `metadata.updated` event the effect catches, so\n      // this dispatch is just for an immediate, in-sync update (idempotent).\n      const result = await requireDoc().metadata.update(patch);\n      ctx.dispatch({ type: 'SET', metadata: result.metadata });\n    },\n\n    reload: async () => {\n      const metadata = await requireDoc().metadata.read();\n      ctx.dispatch({ type: 'SET', metadata });\n    },\n  };\n}\n","import type { DocumentEvent, EffectContext } from '@embedpdf/core';\nimport type { MetadataAction, MetadataState } from './types';\n\n/**\n * Makes metadata REACTIVE — the reason this is a plugin, not a kernel IO call.\n *\n *  1. Seed: read the Info dict once when the document opens.\n *  2. Live: subscribe to the document event stream. A `metadata.updated` event\n *     carries the full re-read metadata and fires for OWN edits AND for remote\n *     edits delivered over SSE (another session) — both just become `setState`.\n *\n * The handle's stream is synchronous fan-out, so this coexists with the kernel's\n * own subscription (page registry) on the same handle.\n */\nexport function registerMetadataEffects(ctx: EffectContext<MetadataState, MetadataAction>): void {\n  const doc = ctx.doc;\n  if (!doc) return;\n\n  // 1. seed\n  void doc.metadata.read().then(\n    (metadata) => ctx.dispatch({ type: 'SET', metadata }),\n    () => {}, // doc closed / read aborted — ignore\n  );\n\n  // 2. live updates (own edits + remote SSE edits)\n  const unsubscribe = doc.events.subscribe((event: DocumentEvent) => {\n    if (event.type === 'metadata.updated') {\n      ctx.dispatch({ type: 'SET', metadata: event.metadata });\n    }\n  });\n  ctx.cleanup(unsubscribe);\n}\n","import type { MetadataAction, MetadataState } from './types';\n\nexport const initialMetadataState = (): MetadataState => ({ metadata: null });\n\n/** Pure. The only transition: replace the metadata snapshot (from a read or an\n *  event). */\nexport const metadataReducer = (state: MetadataState, a: MetadataAction): MetadataState =>\n  a.type === 'SET' ? { ...state, metadata: a.metadata } : state;\n","import { definePlugin } from '@embedpdf/core';\nimport { createMetadataCapability } from './capability';\nimport { registerMetadataEffects } from './effects';\nimport { initialMetadataState, metadataReducer } from './reducer';\nimport { MetadataToken } from './types';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it\n * from the engine and keeps it live off the document event stream (own + remote\n * SSE edits); the capability is the read/write surface.\n */\nexport const metadataPlugin = () =>\n  definePlugin<MetadataState, MetadataAction, MetadataCapability>({\n    id: 'metadata',\n    token: MetadataToken,\n    scope: 'document',\n    initialState: initialMetadataState,\n    reduce: metadataReducer,\n    capability: createMetadataCapability,\n    effects: registerMetadataEffects,\n  });\n"],"mappings":";;;;;;;;;;;AAUA,MAAM,6BAA4C;;;;;;AAOlD,SAAgB,yBACd,KACoB;CACpB,MAAM,mBAAmB;EACvB,MAAM,MAAM,IAAI;EAChB,IAAI,CAAC,KAAK,MAAM,IAAI,MAAM,8BAA8B;EACxD,OAAO;CACT;CAEA,OAAO;EACL,UAAU;GAKR,OAAO,IAAI,KAAK,SAAS,OAAO,0BAA0B,KAAK;EACjE;EAEA,eAAe,IAAI,SAAS,CAAC,CAAC;EAE9B,QAAQ,OAAO,UAAU;GAGvB,MAAM,SAAS,MAAM,WAAW,CAAC,CAAC,SAAS,OAAO,KAAK;GACvD,IAAI,SAAS;IAAE,MAAM;IAAO,UAAU,OAAO;GAAS,CAAC;EACzD;EAEA,QAAQ,YAAY;GAClB,MAAM,WAAW,MAAM,WAAW,CAAC,CAAC,SAAS,KAAK;GAClD,IAAI,SAAS;IAAE,MAAM;IAAO;GAAS,CAAC;EACxC;CACF;AACF;;;;;;;;;;;;;;ACnCA,SAAgB,wBAAwB,KAAyD;CAC/F,MAAM,MAAM,IAAI;CAChB,IAAI,CAAC,KAAK;CAGV,IAAS,SAAS,KAAK,CAAC,CAAC,MACtB,aAAa,IAAI,SAAS;EAAE,MAAM;EAAO;CAAS,CAAC,SAC9C,CAAC,CACT;CAGA,MAAM,cAAc,IAAI,OAAO,WAAW,UAAyB;EACjE,IAAI,MAAM,SAAS,oBACjB,IAAI,SAAS;GAAE,MAAM;GAAO,UAAU,MAAM;EAAS,CAAC;CAE1D,CAAC;CACD,IAAI,QAAQ,WAAW;AACzB;;;AC7BA,MAAa,8BAA6C,EAAE,UAAU,KAAK;;;AAI3E,MAAa,mBAAmB,OAAsB,MACpD,EAAE,SAAS,QAAQ;CAAE,GAAG;CAAO,UAAU,EAAE;AAAS,IAAI;;;;;;;;ACK1D,MAAa,wBAAA,GAAA,eAAA,aAAA,CACqD;CAC9D,IAAI;CACJ,OAAOA,iBAAAA;CACP,OAAO;CACP,cAAc;CACd,QAAQ;CACR,YAAY;CACZ,SAAS;AACX,CAAC"}

package/dist/index.d.cts

@@ -1,41 +1,4 @@
-import { DocumentMetadata, MetadataPatch } from "@embedpdf/core";
-//#region src/types.d.ts
-/**
- * The document's Info-dict metadata, held as REACTIVE state — not a one-shot
- * read. It changes from local edits AND from other sessions (a remote edit
- * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to
- * the document event stream and keeps `current()` live. `update` writes a
- * three-state patch into the LAYER (like a page mutation), so a metadata edit
- * saves with the layer.
- */
-interface MetadataState {
-  /** Current metadata, or null until the first read resolves. */
-  metadata: DocumentMetadata | null;
-}
-type MetadataAction = {
-  type: 'SET';
-  metadata: DocumentMetadata | null;
-};
-interface MetadataCapability {
-  /**
-   * Whether this caller is authorized to edit the Info dict —
-   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their
-   * edit affordances on this; the engine independently enforces the same
-   * capability and throws `PermissionDenied` if a write slips through.
-   */
-  canEdit(): boolean;
-  /** Current metadata; null until the initial read lands. Reactive — reflects
-   *  own edits and remote (SSE) edits via the event stream. */
-  current(): DocumentMetadata | null;
-  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the
-   *  layer; state refreshes from the resulting `metadata.updated` event. */
-  update(patch: MetadataPatch): Promise<void>;
-  /** Force a re-read from the engine (rarely needed — the event stream keeps
-   *  state fresh). */
-  reload(): Promise<void>;
-}
-declare const MetadataToken: import("@embedpdf/core").CapabilityToken<MetadataCapability>;
-//#endregion
+import { i as MetadataToken, n as MetadataCapability, r as MetadataState, t as MetadataAction } from "./contract-Dk5SGhEP.cjs";
 //#region src/metadata.plugin.d.ts
 /**
  * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it

package/dist/index.d.ts

@@ -1,41 +1,4 @@
-import { DocumentMetadata, MetadataPatch } from "@embedpdf/core";
-//#region src/types.d.ts
-/**
- * The document's Info-dict metadata, held as REACTIVE state — not a one-shot
- * read. It changes from local edits AND from other sessions (a remote edit
- * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to
- * the document event stream and keeps `current()` live. `update` writes a
- * three-state patch into the LAYER (like a page mutation), so a metadata edit
- * saves with the layer.
- */
-interface MetadataState {
-  /** Current metadata, or null until the first read resolves. */
-  metadata: DocumentMetadata | null;
-}
-type MetadataAction = {
-  type: 'SET';
-  metadata: DocumentMetadata | null;
-};
-interface MetadataCapability {
-  /**
-   * Whether this caller is authorized to edit the Info dict —
-   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their
-   * edit affordances on this; the engine independently enforces the same
-   * capability and throws `PermissionDenied` if a write slips through.
-   */
-  canEdit(): boolean;
-  /** Current metadata; null until the initial read lands. Reactive — reflects
-   *  own edits and remote (SSE) edits via the event stream. */
-  current(): DocumentMetadata | null;
-  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the
-   *  layer; state refreshes from the resulting `metadata.updated` event. */
-  update(patch: MetadataPatch): Promise<void>;
-  /** Force a re-read from the engine (rarely needed — the event stream keeps
-   *  state fresh). */
-  reload(): Promise<void>;
-}
-declare const MetadataToken: import("@embedpdf/core").CapabilityToken<MetadataCapability>;
-//#endregion
+import { i as MetadataToken, n as MetadataCapability, r as MetadataState, t as MetadataAction } from "./contract-Dk5SGhEP.js";
 //#region src/metadata.plugin.d.ts
 /**
  * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it

package/dist/index.js

@@ -1,4 +1,5 @@
-import { createCapabilityToken, definePlugin } from "@embedpdf/core";
+import { t as MetadataToken } from "./contract-DXGV7Wpx.js";
+import { definePlugin } from "@embedpdf/core";
 //#region src/capability.ts
 /**
 * Authorization for Info-dict writes. Maps to PDF bit 4 (MODIFY). The engine
@@ -78,9 +79,6 @@ const metadataReducer = (state, a) => a.type === "SET" ? {
 	metadata: a.metadata
 } : state;
 //#endregion
-//#region src/types.ts
-const MetadataToken = createCapabilityToken("metadata");
-//#endregion
 //#region src/metadata.plugin.ts
 /**
 * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/capability.ts","../src/effects.ts","../src/reducer.ts","../src/types.ts","../src/metadata.plugin.ts"],"sourcesContent":["import type { PluginContext, DocCapability } from '@embedpdf/core';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Authorization for Info-dict writes. Maps to PDF bit 4 (MODIFY). The engine\n * ALSO enforces this — `metadata.update` throws `PermissionDenied` without it,\n * identically on local and cloud — so `canEdit()` is the UI mirror of a real\n * guard, not the guard itself. Typed as `DocCapability` so a typo is a compile\n * error.\n */\nconst METADATA_MODIFY_CAPABILITY: DocCapability = 'doc.metadata.modify';\n\n/**\n * Reads/writes the document's Info dict through the engine handle and keeps the\n * plugin's state in sync. The live-update wiring (own + remote events) lives in\n * the effect; this is the read/write surface.\n */\nexport function createMetadataCapability(\n  ctx: PluginContext<MetadataState, MetadataAction>,\n): MetadataCapability {\n  const requireDoc = () => {\n    const doc = ctx.doc;\n    if (!doc) throw new Error('[metadata] no document bound');\n    return doc;\n  };\n\n  return {\n    canEdit() {\n      // Wildcard-aware predicate (mirrors the engine's own enforcement),\n      // identical on both engines. NOT `effectiveScope.includes(...)` — that\n      // enumeration drops the `*` admin grant, so it would hide the UI on a\n      // default admin open even though the engine allows the edit.\n      return ctx.doc?.security.allows(METADATA_MODIFY_CAPABILITY) ?? false;\n    },\n\n    current: () => ctx.getState().metadata,\n\n    update: async (patch) => {\n      // The write also emits a `metadata.updated` event the effect catches, so\n      // this dispatch is just for an immediate, in-sync update (idempotent).\n      const result = await requireDoc().metadata.update(patch);\n      ctx.dispatch({ type: 'SET', metadata: result.metadata });\n    },\n\n    reload: async () => {\n      const metadata = await requireDoc().metadata.read();\n      ctx.dispatch({ type: 'SET', metadata });\n    },\n  };\n}\n","import type { DocumentEvent, EffectContext } from '@embedpdf/core';\nimport type { MetadataAction, MetadataState } from './types';\n\n/**\n * Makes metadata REACTIVE — the reason this is a plugin, not a kernel IO call.\n *\n *  1. Seed: read the Info dict once when the document opens.\n *  2. Live: subscribe to the document event stream. A `metadata.updated` event\n *     carries the full re-read metadata and fires for OWN edits AND for remote\n *     edits delivered over SSE (another session) — both just become `setState`.\n *\n * The handle's stream is synchronous fan-out, so this coexists with the kernel's\n * own subscription (page registry) on the same handle.\n */\nexport function registerMetadataEffects(ctx: EffectContext<MetadataState, MetadataAction>): void {\n  const doc = ctx.doc;\n  if (!doc) return;\n\n  // 1. seed\n  void doc.metadata.read().then(\n    (metadata) => ctx.dispatch({ type: 'SET', metadata }),\n    () => {}, // doc closed / read aborted — ignore\n  );\n\n  // 2. live updates (own edits + remote SSE edits)\n  const unsubscribe = doc.events.subscribe((event: DocumentEvent) => {\n    if (event.type === 'metadata.updated') {\n      ctx.dispatch({ type: 'SET', metadata: event.metadata });\n    }\n  });\n  ctx.cleanup(unsubscribe);\n}\n","import type { MetadataAction, MetadataState } from './types';\n\nexport const initialMetadataState = (): MetadataState => ({ metadata: null });\n\n/** Pure. The only transition: replace the metadata snapshot (from a read or an\n *  event). */\nexport const metadataReducer = (state: MetadataState, a: MetadataAction): MetadataState =>\n  a.type === 'SET' ? { ...state, metadata: a.metadata } : state;\n","import { createCapabilityToken, type DocumentMetadata, type MetadataPatch } from '@embedpdf/core';\n\n/**\n * The document's Info-dict metadata, held as REACTIVE state — not a one-shot\n * read. It changes from local edits AND from other sessions (a remote edit\n * arrives over SSE as a `metadata.updated` event), so the plugin subscribes to\n * the document event stream and keeps `current()` live. `update` writes a\n * three-state patch into the LAYER (like a page mutation), so a metadata edit\n * saves with the layer.\n */\nexport interface MetadataState {\n  /** Current metadata, or null until the first read resolves. */\n  metadata: DocumentMetadata | null;\n}\n\nexport type MetadataAction = { type: 'SET'; metadata: DocumentMetadata | null };\n\nexport interface MetadataCapability {\n  /**\n   * Whether this caller is authorized to edit the Info dict —\n   * `effectiveScope` includes `doc.metadata.modify` (PDF bit 4). UIs gate their\n   * edit affordances on this; the engine independently enforces the same\n   * capability and throws `PermissionDenied` if a write slips through.\n   */\n  canEdit(): boolean;\n  /** Current metadata; null until the initial read lands. Reactive — reflects\n   *  own edits and remote (SSE) edits via the event stream. */\n  current(): DocumentMetadata | null;\n  /** Patch the Info dict (undefined=leave, null=clear, value=set). Writes to the\n   *  layer; state refreshes from the resulting `metadata.updated` event. */\n  update(patch: MetadataPatch): Promise<void>;\n  /** Force a re-read from the engine (rarely needed — the event stream keeps\n   *  state fresh). */\n  reload(): Promise<void>;\n}\n\nexport const MetadataToken = createCapabilityToken<MetadataCapability>('metadata');\n","import { definePlugin } from '@embedpdf/core';\nimport { createMetadataCapability } from './capability';\nimport { registerMetadataEffects } from './effects';\nimport { initialMetadataState, metadataReducer } from './reducer';\nimport { MetadataToken } from './types';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it\n * from the engine and keeps it live off the document event stream (own + remote\n * SSE edits); the capability is the read/write surface.\n */\nexport const metadataPlugin = () =>\n  definePlugin<MetadataState, MetadataAction, MetadataCapability>({\n    id: 'metadata',\n    token: MetadataToken,\n    scope: 'document',\n    initialState: initialMetadataState,\n    reduce: metadataReducer,\n    capability: createMetadataCapability,\n    effects: registerMetadataEffects,\n  });\n"],"mappings":";;;;;;;;;AAUA,MAAM,6BAA4C;;;;;;AAOlD,SAAgB,yBACd,KACoB;CACpB,MAAM,mBAAmB;EACvB,MAAM,MAAM,IAAI;EAChB,IAAI,CAAC,KAAK,MAAM,IAAI,MAAM,8BAA8B;EACxD,OAAO;CACT;CAEA,OAAO;EACL,UAAU;GAKR,OAAO,IAAI,KAAK,SAAS,OAAO,0BAA0B,KAAK;EACjE;EAEA,eAAe,IAAI,SAAS,CAAC,CAAC;EAE9B,QAAQ,OAAO,UAAU;GAGvB,MAAM,SAAS,MAAM,WAAW,CAAC,CAAC,SAAS,OAAO,KAAK;GACvD,IAAI,SAAS;IAAE,MAAM;IAAO,UAAU,OAAO;GAAS,CAAC;EACzD;EAEA,QAAQ,YAAY;GAClB,MAAM,WAAW,MAAM,WAAW,CAAC,CAAC,SAAS,KAAK;GAClD,IAAI,SAAS;IAAE,MAAM;IAAO;GAAS,CAAC;EACxC;CACF;AACF;;;;;;;;;;;;;;ACnCA,SAAgB,wBAAwB,KAAyD;CAC/F,MAAM,MAAM,IAAI;CAChB,IAAI,CAAC,KAAK;CAGV,IAAS,SAAS,KAAK,CAAC,CAAC,MACtB,aAAa,IAAI,SAAS;EAAE,MAAM;EAAO;CAAS,CAAC,SAC9C,CAAC,CACT;CAGA,MAAM,cAAc,IAAI,OAAO,WAAW,UAAyB;EACjE,IAAI,MAAM,SAAS,oBACjB,IAAI,SAAS;GAAE,MAAM;GAAO,UAAU,MAAM;EAAS,CAAC;CAE1D,CAAC;CACD,IAAI,QAAQ,WAAW;AACzB;;;AC7BA,MAAa,8BAA6C,EAAE,UAAU,KAAK;;;AAI3E,MAAa,mBAAmB,OAAsB,MACpD,EAAE,SAAS,QAAQ;CAAE,GAAG;CAAO,UAAU,EAAE;AAAS,IAAI;;;AC6B1D,MAAa,gBAAgB,sBAA0C,UAAU;;;;;;;;ACxBjF,MAAa,uBACX,aAAgE;CAC9D,IAAI;CACJ,OAAO;CACP,OAAO;CACP,cAAc;CACd,QAAQ;CACR,YAAY;CACZ,SAAS;AACX,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/capability.ts","../src/effects.ts","../src/reducer.ts","../src/metadata.plugin.ts"],"sourcesContent":["import type { PluginContext, DocCapability } from '@embedpdf/core';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Authorization for Info-dict writes. Maps to PDF bit 4 (MODIFY). The engine\n * ALSO enforces this — `metadata.update` throws `PermissionDenied` without it,\n * identically on local and cloud — so `canEdit()` is the UI mirror of a real\n * guard, not the guard itself. Typed as `DocCapability` so a typo is a compile\n * error.\n */\nconst METADATA_MODIFY_CAPABILITY: DocCapability = 'doc.metadata.modify';\n\n/**\n * Reads/writes the document's Info dict through the engine handle and keeps the\n * plugin's state in sync. The live-update wiring (own + remote events) lives in\n * the effect; this is the read/write surface.\n */\nexport function createMetadataCapability(\n  ctx: PluginContext<MetadataState, MetadataAction>,\n): MetadataCapability {\n  const requireDoc = () => {\n    const doc = ctx.doc;\n    if (!doc) throw new Error('[metadata] no document bound');\n    return doc;\n  };\n\n  return {\n    canEdit() {\n      // Wildcard-aware predicate (mirrors the engine's own enforcement),\n      // identical on both engines. NOT `effectiveScope.includes(...)` — that\n      // enumeration drops the `*` admin grant, so it would hide the UI on a\n      // default admin open even though the engine allows the edit.\n      return ctx.doc?.security.allows(METADATA_MODIFY_CAPABILITY) ?? false;\n    },\n\n    current: () => ctx.getState().metadata,\n\n    update: async (patch) => {\n      // The write also emits a `metadata.updated` event the effect catches, so\n      // this dispatch is just for an immediate, in-sync update (idempotent).\n      const result = await requireDoc().metadata.update(patch);\n      ctx.dispatch({ type: 'SET', metadata: result.metadata });\n    },\n\n    reload: async () => {\n      const metadata = await requireDoc().metadata.read();\n      ctx.dispatch({ type: 'SET', metadata });\n    },\n  };\n}\n","import type { DocumentEvent, EffectContext } from '@embedpdf/core';\nimport type { MetadataAction, MetadataState } from './types';\n\n/**\n * Makes metadata REACTIVE — the reason this is a plugin, not a kernel IO call.\n *\n *  1. Seed: read the Info dict once when the document opens.\n *  2. Live: subscribe to the document event stream. A `metadata.updated` event\n *     carries the full re-read metadata and fires for OWN edits AND for remote\n *     edits delivered over SSE (another session) — both just become `setState`.\n *\n * The handle's stream is synchronous fan-out, so this coexists with the kernel's\n * own subscription (page registry) on the same handle.\n */\nexport function registerMetadataEffects(ctx: EffectContext<MetadataState, MetadataAction>): void {\n  const doc = ctx.doc;\n  if (!doc) return;\n\n  // 1. seed\n  void doc.metadata.read().then(\n    (metadata) => ctx.dispatch({ type: 'SET', metadata }),\n    () => {}, // doc closed / read aborted — ignore\n  );\n\n  // 2. live updates (own edits + remote SSE edits)\n  const unsubscribe = doc.events.subscribe((event: DocumentEvent) => {\n    if (event.type === 'metadata.updated') {\n      ctx.dispatch({ type: 'SET', metadata: event.metadata });\n    }\n  });\n  ctx.cleanup(unsubscribe);\n}\n","import type { MetadataAction, MetadataState } from './types';\n\nexport const initialMetadataState = (): MetadataState => ({ metadata: null });\n\n/** Pure. The only transition: replace the metadata snapshot (from a read or an\n *  event). */\nexport const metadataReducer = (state: MetadataState, a: MetadataAction): MetadataState =>\n  a.type === 'SET' ? { ...state, metadata: a.metadata } : state;\n","import { definePlugin } from '@embedpdf/core';\nimport { createMetadataCapability } from './capability';\nimport { registerMetadataEffects } from './effects';\nimport { initialMetadataState, metadataReducer } from './reducer';\nimport { MetadataToken } from './types';\nimport type { MetadataAction, MetadataCapability, MetadataState } from './types';\n\n/**\n * Document-scoped metadata plugin: reactive Info-dict state. The effect seeds it\n * from the engine and keeps it live off the document event stream (own + remote\n * SSE edits); the capability is the read/write surface.\n */\nexport const metadataPlugin = () =>\n  definePlugin<MetadataState, MetadataAction, MetadataCapability>({\n    id: 'metadata',\n    token: MetadataToken,\n    scope: 'document',\n    initialState: initialMetadataState,\n    reduce: metadataReducer,\n    capability: createMetadataCapability,\n    effects: registerMetadataEffects,\n  });\n"],"mappings":";;;;;;;;;;AAUA,MAAM,6BAA4C;;;;;;AAOlD,SAAgB,yBACd,KACoB;CACpB,MAAM,mBAAmB;EACvB,MAAM,MAAM,IAAI;EAChB,IAAI,CAAC,KAAK,MAAM,IAAI,MAAM,8BAA8B;EACxD,OAAO;CACT;CAEA,OAAO;EACL,UAAU;GAKR,OAAO,IAAI,KAAK,SAAS,OAAO,0BAA0B,KAAK;EACjE;EAEA,eAAe,IAAI,SAAS,CAAC,CAAC;EAE9B,QAAQ,OAAO,UAAU;GAGvB,MAAM,SAAS,MAAM,WAAW,CAAC,CAAC,SAAS,OAAO,KAAK;GACvD,IAAI,SAAS;IAAE,MAAM;IAAO,UAAU,OAAO;GAAS,CAAC;EACzD;EAEA,QAAQ,YAAY;GAClB,MAAM,WAAW,MAAM,WAAW,CAAC,CAAC,SAAS,KAAK;GAClD,IAAI,SAAS;IAAE,MAAM;IAAO;GAAS,CAAC;EACxC;CACF;AACF;;;;;;;;;;;;;;ACnCA,SAAgB,wBAAwB,KAAyD;CAC/F,MAAM,MAAM,IAAI;CAChB,IAAI,CAAC,KAAK;CAGV,IAAS,SAAS,KAAK,CAAC,CAAC,MACtB,aAAa,IAAI,SAAS;EAAE,MAAM;EAAO;CAAS,CAAC,SAC9C,CAAC,CACT;CAGA,MAAM,cAAc,IAAI,OAAO,WAAW,UAAyB;EACjE,IAAI,MAAM,SAAS,oBACjB,IAAI,SAAS;GAAE,MAAM;GAAO,UAAU,MAAM;EAAS,CAAC;CAE1D,CAAC;CACD,IAAI,QAAQ,WAAW;AACzB;;;AC7BA,MAAa,8BAA6C,EAAE,UAAU,KAAK;;;AAI3E,MAAa,mBAAmB,OAAsB,MACpD,EAAE,SAAS,QAAQ;CAAE,GAAG;CAAO,UAAU,EAAE;AAAS,IAAI;;;;;;;;ACK1D,MAAa,uBACX,aAAgE;CAC9D,IAAI;CACJ,OAAO;CACP,OAAO;CACP,cAAc;CACd,QAAQ;CACR,YAAY;CACZ,SAAS;AACX,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embedpdf/plugin-metadata",
-  "version": "3.0.0-next.10",
+  "version": "3.0.0-next.12",
   "private": false,
   "description": "Document-scoped metadata: reactive Info-dict state fed by the document event stream (own edits + remote SSE), with a three-state update that writes to the layer.",
   "type": "module",
@@ -12,13 +12,17 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./contract": {
+      "import": "./dist/contract.js",
+      "require": "./dist/contract.cjs"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@embedpdf/core": "3.0.0-next.10"
+    "@embedpdf/core": "3.0.0-next.12"
   },
   "devDependencies": {
     "typescript": "^5.0.0",