@triiiceratops/plugin-annotation-editor 1.0.0-rc.1

package/dist/loader.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { ViewerState } from 'triiiceratops';
+import type { AnnotationStore } from './AnnotationStore.svelte';
+/**
+ * Creates a reactive loader that syncs annotations from storage to the viewer's
+ * read-only overlay. It runs independently of the Annotation Editor UI component
+ * (the panel may never open), so it drives the shared store directly: point the
+ * store at the current canvas and load; the store injects into this viewer's
+ * per-viewer display state (F10, ADR 0007). When the editor panel is mounted,
+ * its manager shares this same store, so both paths converge on one cache.
+ */
+export declare function createLoader(store: AnnotationStore): (viewerState: ViewerState) => void;

package/dist/mount.svelte.d.ts

@@ -0,0 +1,3 @@
+import type { PluginContext } from '@triiiceratops/plugin-sdk';
+import type { AnnotationEditorConfig } from './types';
+export declare function mountAnnotationEditor(container: HTMLElement, context: PluginContext, config: AnnotationEditorConfig): () => void;

package/dist/plugin.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The annotation-editor plugin, authored on `@triiiceratops/plugin-sdk`.
+ *
+ * `definePlugin` returns the framework-neutral factory core activates through the
+ * structural seam (it carries its own `activate(host)`); core never imports this
+ * package or its Svelte runtime. The full domain machinery — Store, Adapter seam,
+ * per-viewer display sync, undo/redo, body editors, Annotorious integration — is
+ * carried intact and driven from the neutral `view.mount(container, context)`
+ * contract (see `mount.svelte.ts`). Annotorious needs the raw OSD viewer, so the
+ * plugin declares `requiredCapabilities: ['osd@5']` (ADR 0009).
+ */
+import { type SdkPlugin } from '@triiiceratops/plugin-sdk';
+import type { AnnotationEditorConfig } from './types';
+/**
+ * Create an annotation-editor plugin with custom configuration.
+ *
+ * @example
+ * ```ts
+ * import {
+ *     createAnnotationEditorPlugin,
+ *     LocalStorageAdapter,
+ * } from '@triiiceratops/plugin-annotation-editor';
+ *
+ * const annotationPlugin = createAnnotationEditorPlugin({
+ *     adapter: new LocalStorageAdapter(),
+ *     user: { id: 'user-123', name: 'Jane Doe' },
+ * });
+ * // Svelte:  <TriiiceratopsViewer plugins={[annotationPlugin]} />
+ * // WC:      viewer.plugins = [annotationPlugin];
+ * ```
+ */
+export declare function createAnnotationEditorPlugin(config?: AnnotationEditorConfig): SdkPlugin;
+/**
+ * Pre-configured annotation-editor plugin with the LocalStorage adapter. For
+ * advanced configuration use {@link createAnnotationEditorPlugin}.
+ */
+export declare const AnnotationEditorPlugin: SdkPlugin;

package/dist/styles.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The combined stylesheet (base Annotorious sheet + layer fixes) installed under
+ * the `annotorious` id at activation, shaped by {@link definePluginStyles} into
+ * the `STYLES` / `STYLE_ID` exports.
+ *
+ * No plugin chrome CSS lives here anymore: core owns the toolbar button and the
+ * docked-panel / anchored-flyout surface (epic restore-plugin-toolbar-chrome),
+ * so the plugin ships only the Annotorious annotation-layer styles. The panel's
+ * own presentation is scoped component CSS rendered inside `view.mount`.
+ */
+export declare const STYLES: string, STYLE_ID: string;

package/dist/testing/index.d.ts

@@ -0,0 +1,48 @@
+import type { AnnotationStorageAdapter } from '../types';
+/**
+ * Adapter authoring kit — a reusable conformance suite so adapter authors can
+ * verify their implementation against the contract the plugin relies on (ticket
+ * 10, F28 / SPEC §2.6).
+ *
+ * An adapter is pure storage: the plugin owns display sync, caching, id
+ * bookkeeping, timestamp/attribution stamping, and error handling. This suite
+ * therefore checks only storage behavior — load/create/update/delete round-trips,
+ * verbatim body preservation (including structured/unknown shapes), key isolation,
+ * and the two opt-in capabilities (server-assigned ids and hydrate).
+ *
+ * @example
+ * ```ts
+ * import { runAdapterContractTests } from '@triiiceratops/plugin-annotation-editor/testing';
+ * import { MyAdapter } from './MyAdapter';
+ *
+ * runAdapterContractTests(() => new MyAdapter(), {
+ *   supportsIdReconciliation: true,
+ *   supportsHydrate: true,
+ * });
+ * ```
+ */
+export interface AdapterContractOptions {
+    /**
+     * The adapter mints its own canonical id on `create` and returns it (as an
+     * annotation or an id string). When set, the suite asserts `create` returns a
+     * non-void value and that the returned id is honored by subsequent
+     * `update`/`delete` (F5).
+     */
+    supportsIdReconciliation?: boolean;
+    /**
+     * The adapter implements `hydrate`. When set, the suite asserts `hydrate`
+     * exists, returns the full annotation for a known id, and returns `null` for
+     * an unknown id.
+     */
+    supportsHydrate?: boolean;
+    /** Overrides the `describe` block label. */
+    label?: string;
+}
+/**
+ * Register the adapter conformance suite for `factory()`. Call at the top level
+ * of a vitest test file; `factory` is invoked fresh before each test so a
+ * stateful adapter starts clean, and every test uses a unique manifest/canvas
+ * pair so tests can't bleed into each other (important for storage-backed
+ * adapters like `LocalStorageAdapter`).
+ */
+export declare function runAdapterContractTests(factory: () => AnnotationStorageAdapter, options?: AdapterContractOptions): void;

package/dist/testing/index.js

@@ -0,0 +1,158 @@
+import { describe as _, beforeEach as A, it as c, expect as n } from "vitest";
+function w(i) {
+  const u = { ...i };
+  return delete u.__fullBodyLoaded, delete u.__bodyPreview, u;
+}
+function b(i, u) {
+  return typeof i == "string" ? i : i && typeof i == "object" ? i.id : u;
+}
+function f(i, u, h) {
+  return {
+    "@context": "http://www.w3.org/ns/anno.jsonld",
+    id: i,
+    type: "Annotation",
+    motivation: "commenting",
+    body: h ?? [
+      { type: "TextualBody", purpose: "commenting", value: "hello" }
+    ],
+    target: {
+      type: "SpecificResource",
+      source: u,
+      selector: {
+        type: "FragmentSelector",
+        conformsTo: "http://www.w3.org/TR/media-frags/",
+        value: "xywh=10,20,30,40"
+      }
+    }
+  };
+}
+function C(i, u = {}) {
+  const { supportsIdReconciliation: h, supportsHydrate: g, label: x } = u;
+  _(x ?? "AnnotationStorageAdapter contract", () => {
+    let o, d, t, m = 0;
+    A(() => {
+      o = i(), m += 1, d = `contract-manifest-${m}`, t = `contract-canvas-${m}`;
+    });
+    async function p(a) {
+      const r = await o.create(
+        d,
+        t,
+        structuredClone(a)
+      ), e = b(r, a.id), s = (await o.load(d, t)).find((l) => l.id === e) ?? null;
+      if (!s) return { id: e, resolved: null };
+      if (s.__fullBodyLoaded === !1) {
+        n(typeof o.hydrate).toBe("function");
+        const l = await o.hydrate(d, t, e);
+        return { id: e, resolved: l };
+      }
+      return { id: e, resolved: s };
+    }
+    c("load returns an empty array for a canvas with no annotations", async () => {
+      const a = await o.load(d, t);
+      n(Array.isArray(a)).toBe(!0), n(a).toHaveLength(0);
+    }), c("create then load round-trips the annotation verbatim", async () => {
+      const a = f("anno-1", t), { id: r, resolved: e } = await p(a);
+      n(e).not.toBeNull(), n(w(e)).toEqual({
+        ...a,
+        id: r
+      });
+    }), c("create preserves structured / unknown body shapes verbatim", async () => {
+      const a = {
+        type: "Dataset",
+        purpose: "linking",
+        value: {
+          nested: { deep: [1, 2, 3], flag: !0 },
+          ref: "https://example.org/entity/42"
+        },
+        extra: null
+      }, r = f(
+        "anno-structured",
+        t,
+        a
+      ), { resolved: e } = await p(r);
+      n(e).not.toBeNull(), n(e.body).toEqual(a);
+    }), c("update replaces a stored annotation body", async () => {
+      const a = f("anno-2", t), { id: r } = await p(a), e = {
+        ...a,
+        id: r,
+        body: [
+          {
+            type: "TextualBody",
+            purpose: "commenting",
+            value: "edited"
+          }
+        ]
+      };
+      await o.update(
+        d,
+        t,
+        structuredClone(e)
+      );
+      const s = (await o.load(d, t)).find((v) => v.id === r);
+      n(s).toBeDefined();
+      const l = s?.__fullBodyLoaded === !1 ? await o.hydrate(d, t, r) : s;
+      n(w(l).body).toEqual(e.body);
+    }), c("delete removes a stored annotation", async () => {
+      const a = f("anno-3", t), { id: r } = await p(a);
+      await o.delete(d, t, r);
+      const e = await o.load(d, t);
+      n(e.find((y) => y.id === r)).toBeUndefined();
+    }), c("isolates annotations by manifest and canvas", async () => {
+      const a = f("anno-iso", t), { id: r } = await p(a), e = `${t}-other`, y = `${d}-other`;
+      n(await o.load(d, e)).toHaveLength(0), n(await o.load(y, t)).toHaveLength(0);
+      const s = await o.load(d, t);
+      n(s.find((l) => l.id === r)).toBeDefined();
+    }), h && c("returns a server-assigned id honored by update and delete", async () => {
+      const a = f("local-temp-id", t), r = await o.create(
+        d,
+        t,
+        structuredClone(a)
+      );
+      n(r == null).toBe(!1);
+      const e = b(r, a.id);
+      n(typeof e).toBe("string");
+      const y = {
+        ...a,
+        id: e,
+        body: [
+          {
+            type: "TextualBody",
+            purpose: "commenting",
+            value: "reconciled-edit"
+          }
+        ]
+      };
+      await o.update(
+        d,
+        t,
+        structuredClone(y)
+      );
+      let s = await o.load(d, t);
+      const l = s.find((B) => B.id === e);
+      n(l).toBeDefined();
+      const v = l?.__fullBodyLoaded === !1 ? await o.hydrate(
+        d,
+        t,
+        e
+      ) : l;
+      n(w(v).body).toEqual(y.body), await o.delete(d, t, e), s = await o.load(d, t), n(
+        s.find((B) => B.id === e)
+      ).toBeUndefined();
+    }), g && (c("exposes a hydrate method", () => {
+      n(typeof o.hydrate).toBe("function");
+    }), c("hydrate returns the full annotation for a known id", async () => {
+      const a = f("anno-hydrate", t), { id: r } = await p(a), e = await o.hydrate(d, t, r);
+      n(e).not.toBeNull(), n(w(e).body).toEqual(a.body);
+    }), c("hydrate returns null for an unknown id", async () => {
+      const a = await o.hydrate(
+        d,
+        t,
+        "no-such-annotation"
+      );
+      n(a).toBeNull();
+    }));
+  });
+}
+export {
+  C as runAdapterContractTests
+};

package/dist/types.d.ts

@@ -0,0 +1,177 @@
+import type { User, DrawingStyle } from '@annotorious/openseadragon';
+import type { Component } from 'svelte';
+import type { PluginUiTarget } from '@triiiceratops/plugin-sdk';
+import type { PointStyle } from './utils/pointMarker';
+import type { W3CAnnotation, AdapterLoadResult } from './adapters/types';
+export type { PointStyle };
+export interface AnnotationEditorRuntimeContext<HostContext = unknown, TBody = W3CAnnotationBody> {
+    manifestId: string | null;
+    canvasId: string | null;
+    isEditing: boolean;
+    selectedAnnotation: W3CAnnotation<TBody> | null;
+    user?: User;
+    hostContext: HostContext | null;
+}
+export interface AnnotationEditorExtension<HostContext = unknown, TBody = W3CAnnotationBody> {
+    getContext?: () => HostContext | null;
+    /**
+     * Subscribe to host-context changes. Call `invalidate` when canCreate or
+     * getCreateDisabledReason should re-evaluate; return an unsubscribe.
+     */
+    subscribe?: (invalidate: () => void) => () => void;
+    canCreate?: (context: AnnotationEditorRuntimeContext<HostContext, TBody>) => boolean;
+    getCreateDisabledReason?: (context: AnnotationEditorRuntimeContext<HostContext, TBody>) => string | null;
+    prepareDraft?: (annotation: W3CAnnotation<TBody>, context: AnnotationEditorRuntimeContext<HostContext, TBody>) => W3CAnnotation<TBody>;
+    beforeSave?: (annotation: W3CAnnotation<TBody>, context: AnnotationEditorRuntimeContext<HostContext, TBody>) => W3CAnnotation<TBody> | Promise<W3CAnnotation<TBody>>;
+    onSelectionChange?: (annotation: W3CAnnotation<TBody> | null, context: AnnotationEditorRuntimeContext<HostContext, TBody>) => void;
+}
+export interface AnnotationBodyEditorApi<HostContext = unknown, TBody = W3CAnnotationBody> {
+    /** Full selected annotation in canvas space. */
+    annotation: W3CAnnotation<TBody>;
+    /** Current annotation bodies normalized to an array; body shape is host-owned. */
+    bodies: unknown[];
+    context: AnnotationEditorRuntimeContext<HostContext, TBody>;
+    isHydrating: boolean;
+    save: (bodies: unknown[] | unknown) => Promise<void>;
+    cancel: () => void;
+    requestDelete: () => void;
+}
+export type AnnotationBodyEditor<HostContext = unknown, TBody = W3CAnnotationBody> = {
+    component: Component<{
+        api: AnnotationBodyEditorApi<HostContext, TBody>;
+    }>;
+} | {
+    render: (container: HTMLElement, api: AnnotationBodyEditorApi<HostContext, TBody>) => (() => void) | void;
+};
+export interface AnnotationEditorUiConfig {
+    /** Show the Edit/Create segmented control. Defaults to `true`. */
+    showModeToggle?: boolean;
+    /** Open in create mode when creation is currently allowed. Defaults to `false`. */
+    startInCreateMode?: boolean;
+    /** Show persistence-aware undo/redo buttons. Defaults to `true`. */
+    showUndoRedo?: boolean;
+    /** Purpose choices shown by the built-in body editor. Defaults to `W3C_PURPOSES`. */
+    purposes?: string[];
+    /** Allow adding more body rows in the built-in body editor. Defaults to `true`. */
+    allowMultipleBodies?: boolean;
+}
+/**
+ * The storage contract a host implements to bring its own annotation server.
+ * It is pure storage — the plugin's `AnnotationStore` owns display sync,
+ * caching, id reconciliation, stamping, and error handling — so a conforming
+ * adapter is roughly these five functions (see `LocalStorageAdapter`).
+ *
+ * The `W3CAnnotation` / `AdapterLoadResult` shapes are defined in
+ * `adapters/types.ts`; they are imported here (type-only, so the cycle is
+ * erased at compile time) to keep the adapter contract fully typed.
+ */
+export interface AnnotationStorageAdapter<TBody = W3CAnnotationBody> {
+    readonly id: string;
+    readonly name: string;
+    /**
+     * Return the canvas's annotations. Skeleton entries (bodies not yet loaded)
+     * carry `__fullBodyLoaded: false`; the plugin reads that marker once and
+     * strips it (see {@link AdapterLoadResult}).
+     */
+    load(manifestId: string, canvasId: string): Promise<AdapterLoadResult<TBody>[]>;
+    /** Fetch the full body for a previously-skeleton annotation. */
+    hydrate?(manifestId: string, canvasId: string, annotationId: string): Promise<AdapterLoadResult<TBody> | null>;
+    /**
+     * Persist a new annotation. Servers that mint their own annotation IRI on
+     * create may return the canonical annotation (or just its id string); the
+     * plugin then reconciles the id everywhere. Returning `void` keeps the
+     * client-generated id (the LocalStorageAdapter path).
+     */
+    create(manifestId: string, canvasId: string, annotation: W3CAnnotation<TBody>): Promise<W3CAnnotation<TBody> | string | void>;
+    /**
+     * Persist an update. Returning the (possibly server-normalized) annotation
+     * replaces the cached copy; returning `void` keeps the sent payload.
+     */
+    update(manifestId: string, canvasId: string, annotation: W3CAnnotation<TBody>): Promise<W3CAnnotation<TBody> | void>;
+    delete(manifestId: string, canvasId: string, annotationId: string): Promise<void>;
+    destroy?(): void;
+}
+/** The adapter operations whose failures are surfaced (F20). */
+export type AnnotationPersistenceOp = 'load' | 'create' | 'update' | 'delete' | 'hydrate';
+/**
+ * Structured description of a failed persistence operation handed to
+ * `config.onPersistenceError`. The plugin has already rolled back its optimistic
+ * cache/display changes by the time this fires; `retry()` re-runs the exact
+ * failed operation with the same payload (F20).
+ */
+export interface AnnotationPersistenceError {
+    op: AnnotationPersistenceOp;
+    /** The affected annotation id, when the operation targets one. */
+    annotationId?: string;
+    manifestId: string;
+    canvasId: string;
+    /** The value the adapter threw/rejected with. */
+    cause: unknown;
+    retry: () => Promise<void>;
+}
+export interface AnnotationEditorConfig<TBody = W3CAnnotationBody, THostContext = unknown> {
+    /** Render target for the plugin chrome. Defaults to `'panel'`. */
+    target?: PluginUiTarget;
+    /** Storage adapter for persistence */
+    adapter?: AnnotationStorageAdapter<TBody>;
+    /** Current user for attribution */
+    user?: User;
+    /** Drawing style for annotations while editing */
+    drawingStyle?: DrawingStyle;
+    /**
+     * Marker styling for point annotations (`PointSelector`). Consumed by both
+     * the read-only overlay and the editor so a point looks the same selected or
+     * not; `radius` is in screen pixels. Defaults to a red marker of radius 5
+     * (spec §3.4).
+     */
+    pointStyle?: PointStyle;
+    /** Available drawing tools */
+    tools?: DrawingTool[];
+    /** Default drawing tool */
+    defaultTool?: DrawingTool;
+    /** Optional extension hook surface for host apps */
+    extension?: AnnotationEditorExtension<THostContext, TBody>;
+    /** Optional replacement for the built-in annotation body editor. */
+    bodyEditor?: AnnotationBodyEditor<THostContext, TBody>;
+    /** Optional UI chrome and built-in body editor knobs. */
+    ui?: AnnotationEditorUiConfig;
+    /** Optional hook to prefill a new annotation before its first save */
+    prepareAnnotation?: (annotation: W3CAnnotation<TBody>) => W3CAnnotation<TBody>;
+    /** Optional gate for whether new annotations can be created right now */
+    canCreateAnnotation?: () => boolean;
+    /** Optional status message explaining why creation is unavailable */
+    getCreateDisabledReason?: () => string | null;
+    /**
+     * Motivation stamped onto new annotations that don't already carry one.
+     * Defaults to `'commenting'`. A host-set `motivation` (or one applied by
+     * `extension.beforeSave`) is never overwritten.
+     */
+    defaultMotivation?: string;
+    /**
+     * Called when a persistence operation fails. The plugin has already rolled
+     * back its optimistic cache/display changes and re-signalled selection; the
+     * host decides how to surface the failure and may call `retry()` to re-run
+     * the exact failed operation. When omitted, the plugin logs to the console
+     * and shows a dismissible error line in the panel so failures are never
+     * invisible (F20).
+     */
+    onPersistenceError?: (error: AnnotationPersistenceError) => void;
+}
+export type DrawingTool = 'rectangle' | 'polygon' | 'point';
+/** W3C Annotation Body */
+export interface W3CAnnotationBody {
+    type?: string;
+    purpose?: string;
+    value?: string;
+    format?: string;
+    language?: string;
+    creator?: {
+        id?: string;
+        name?: string;
+    };
+    created?: string;
+    modified?: string;
+}
+/** Standard W3C purposes for autocomplete */
+export declare const W3C_PURPOSES: readonly ["commenting", "tagging", "describing", "classifying", "identifying", "linking", "bookmarking", "highlighting", "questioning", "replying"];
+export type W3CPurpose = (typeof W3C_PURPOSES)[number];

package/dist/utils/iiifTargets.d.ts

@@ -0,0 +1,12 @@
+export type IiifTargetBounds = [number, number, number, number];
+export type NormalizedIiifTarget = {
+    raw: unknown;
+    targetId: string | null;
+    canvasId: string | null;
+    selectors: any[];
+    xywh: IiifTargetBounds | null;
+};
+export declare function parseIiifXywh(value: string): IiifTargetBounds | null;
+export declare function getIiifCanvasId(targetId: string): string | null;
+export declare function extractIiifTargetId(target: unknown): string | null;
+export declare function normalizeIiifTargets(target: unknown): NormalizedIiifTarget[];

package/dist/utils/languageMap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared utility for resolving IIIF language map values.
+ *
+ * IIIF v3 uses language maps: `{ "en": ["Hello"], "fr": ["Bonjour"] }`
+ * Manifesto returns arrays of `{ value, locale/language }` objects.
+ * IIIF v2 may use plain strings.
+ *
+ * This module provides a single resolution strategy used across the viewer.
+ */
+/**
+ * Resolve a IIIF language-mapped value to a single display string.
+ *
+ * Precedence: preferredLocale → 'en' → 'none'/unset → first available.
+ */
+export declare function resolveLanguageValue(value: unknown, preferredLocale?: string): string;
+/**
+ * Resolve a IIIF language-mapped value to all display strings
+ * (for multi-value properties like metadata values with multiple entries
+ * in a single language).
+ */
+export declare function resolveAllLanguageValues(value: unknown, preferredLocale?: string): string[];

package/dist/utils/pointMarker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared point-marker styling for the annotation editor. A point looks the same
+ * whether it is rendered read-only (OSDViewer overlay), selected, or edited, so
+ * the radius/fill/stroke live in one place consumed by both the viewer overlay
+ * and the editor's Annotorious styling (spec §3.4).
+ */
+export interface PointStyle {
+    /** Marker radius in screen (CSS) pixels. */
+    radius?: number;
+    /** Marker fill colour (any CSS colour the consumer renders). */
+    fill?: string;
+    /** Marker stroke colour. */
+    stroke?: string;
+    /** Marker stroke width in pixels. */
+    strokeWidth?: number;
+}
+/**
+ * Default marker radius in screen pixels. Chosen so the diameter (2 × radius)
+ * equals the historical `POINT_MARKER_SIZE = 10` the read-only overlay used, so
+ * existing viewers render unchanged when no `pointStyle` is configured.
+ */
+export declare const DEFAULT_POINT_RADIUS = 5;
+/**
+ * Resolve the effective marker radius (screen pixels) from a `pointStyle`
+ * config, falling back to {@link DEFAULT_POINT_RADIUS} when unset or invalid.
+ */
+export declare function resolvePointRadius(pointStyle?: PointStyle | null): number;

package/dist/viewerMirror.svelte.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Cross-realm reactivity bridge for the plugin's Svelte UI.
+ *
+ * Core's `ViewerState` is compiled by CORE's Svelte runtime; when the plugin (its
+ * OWN Svelte runtime) reads `viewerState.canvasId` inside an `$effect`, no
+ * dependency is registered because the two reactivity graphs don't cross. The
+ * plugin therefore mirrors the handful of fields its UI reacts to
+ * (`manifestId`, `canvasId`, `osdViewer`) into plugin-runtime `$state`, kept in
+ * sync through the framework-neutral `ViewerState.subscribe` fan-out. Every other
+ * member/method (queries, display sync, the annotation-edit bus, the style root)
+ * delegates straight to the real state, so a mirror is a drop-in `ViewerState`
+ * for the controller, loader, manager, and store.
+ */
+import type { ViewerState } from 'triiiceratops';
+export declare class ViewerStateMirror {
+    #private;
+    manifestId: string | null;
+    canvasId: string | null;
+    osdViewer: import("openseadragon").Viewer | null;
+    constructor(real: ViewerState);
+    /** The per-viewer annotation-edit bus (mutated in place by the controller). */
+    get annotationEditBus(): ViewerState['annotationEditBus'];
+    getCanvases(manifestId: string, sequenceIndex?: number): unknown[];
+    getUserAnnotations(manifestId: string, canvasId: string): unknown[];
+    setUserAnnotations(manifestId: string, canvasId: string, annotations: unknown[]): void;
+    clearUserAnnotations(manifestId: string, canvasId: string): void;
+    getStyleRoot(): Document | ShadowRoot | null;
+    /** Drop the bridge's `ViewerState.subscribe` registration. */
+    destroy(): void;
+}
+/** Build a mirror and expose it typed as a `ViewerState` for the plugin UI. */
+export declare function createViewerStateMirror(real: ViewerState): {
+    mirror: ViewerState;
+    destroy: () => void;
+};

package/package.json

@@ -0,0 +1,78 @@
+{
+    "name": "@triiiceratops/plugin-annotation-editor",
+    "version": "1.0.0-rc.1",
+    "type": "module",
+    "description": "Annotation editor plugin for the triiiceratops IIIF viewer, authored on @triiiceratops/plugin-sdk.",
+    "license": "MIT",
+    "author": "David Flood",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/d-flood/triiiceratops.git",
+        "directory": "packages/plugin-annotation-editor"
+    },
+    "homepage": "https://d-flood.github.io/triiiceratops/",
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "private": false,
+    "engines": {
+        "node": ">=22"
+    },
+    "sideEffects": [
+        "./dist/iife.js"
+    ],
+    "files": [
+        "dist",
+        "LICENSE"
+    ],
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./testing": {
+            "types": "./dist/testing/index.d.ts",
+            "import": "./dist/testing/index.js"
+        },
+        "./iife": "./dist/iife.js"
+    },
+    "scripts": {
+        "build": "pnpm build:esm && pnpm build:iife && pnpm build:types",
+        "build:esm": "BUILD_FORMAT=es vite build",
+        "build:iife": "BUILD_FORMAT=iife vite build",
+        "build:types": "tsc -p tsconfig.build.json",
+        "check": "svelte-check --tsconfig ./tsconfig.json --fail-on-warnings && tsc -p tsconfig.build.json --noEmit",
+        "test": "vitest run",
+        "clean": "rm -rf dist",
+        "test:coverage": "vitest run --coverage",
+        "lint": "eslint . --max-warnings 0",
+        "lint:fix": "eslint . --fix --max-warnings 0"
+    },
+    "peerDependencies": {
+        "triiiceratops": "workspace:^",
+        "@triiiceratops/plugin-sdk": "workspace:^"
+    },
+    "dependencies": {
+        "@annotorious/annotorious": "^3.7.19",
+        "@annotorious/openseadragon": "^3.7.19",
+        "openseadragon": "^5.0.1"
+    },
+    "devDependencies": {
+        "@sveltejs/vite-plugin-svelte": "^6.2.1",
+        "@triiiceratops/plugin-sdk": "workspace:*",
+        "@triiiceratops/ui": "workspace:*",
+        "@types/node": "^24.10.1",
+        "@types/openseadragon": "^5.0.1",
+        "@vitest/coverage-v8": "4.0.15",
+        "svelte": "5.45.5",
+        "svelte-check": "^4.3.4",
+        "triiiceratops": "workspace:*",
+        "typescript": "~5.9.3",
+        "vite": "^6.0.0",
+        "vitest": "^4.0.15"
+    }
+}