@yschimke/livery-a2ui 0.0.0-stage → 0.11.0

package/node_modules/@yschimke/livery-web/dist/player.js

@@ -0,0 +1,117 @@
+import { createHostApi, createPlayer } from '../vendor/remote-compose-player.mjs';
+/**
+ * The TypeScript Remote Compose player on a canvas in [container], in the page itself. A document
+ * is loaded once; its named values are set on it while it plays, so a data change moves the values
+ * and never reloads the document (Remote Compose's model, as `LiveryTemplate` does on Compose).
+ */
+export class RcCanvasPlayer {
+    constructor(container, onAction, options = {}) {
+        this.onAction = onAction;
+        this.options = options;
+        this.values = new Map();
+        /** Shows run one after another; one asked for while another runs replaces any still queued. */
+        this.queue = Promise.resolve();
+        this.latest = 0;
+        this.disposed = false;
+        this.epoch = 0;
+        /** Documents loaded and values set, for tests and debugging. */
+        this.stats = { loads: 0, sets: 0 };
+        this.handle = createPlayer(container, {});
+        this.handle.canvas.style.display = 'block';
+        this.host = this.bindHost();
+    }
+    bindHost() {
+        const host = createHostApi(this.handle.player);
+        host.onAction('*', (value, name) => this.onAction({ name: name.replace(/^USER:/, ''), valueType: valueTypeOf(value), value }));
+        return host;
+    }
+    /**
+     * Shows [documentKey]'s document with [values]: loads [document] only when the key differs from
+     * the one playing, then sets each value that changed. A load is asynchronous, so shows are
+     * queued: each waits for the one before it, and a show superseded while it waits does nothing
+     * (resolves `false`), so an older one can never land after a newer one.
+     */
+    show(documentKey, document, values, widthPx, heightPx, density) {
+        const mine = ++this.latest;
+        const run = this.queue.then(async () => {
+            if (this.disposed || mine !== this.latest)
+                return false;
+            await this.apply(documentKey, document, values, widthPx, heightPx, density);
+            return !this.disposed && mine === this.latest;
+        });
+        this.queue = run.catch(() => { });
+        return run;
+    }
+    async apply(documentKey, document, values, widthPx, heightPx, density) {
+        const geometry = `${widthPx}/${heightPx}/${density}`;
+        // Some documents retain stale click regions after reflow; hosts may opt into reloading.
+        if (documentKey !== this.key || (this.options.reloadOnResize && geometry !== this.geometry)) {
+            const epoch = this.epoch;
+            this.handle.player.setDensity(density);
+            // Sized before the load too: the player fixes its touch mapping from the canvas a document
+            // loads into, so a document loaded at the default 256 px missed taps past it.
+            this.resize(widthPx, heightPx, density);
+            await this.handle.loadFromArrayBuffer(document.slice().buffer);
+            if (this.disposed) {
+                this.handle.destroy();
+                return;
+            }
+            if (epoch !== this.epoch)
+                return;
+            // The vendor host observes document replacement on a 50ms timer. Bind a fresh host
+            // now, while the new document is present, so show() never loses an immediate tap.
+            this.host.dispose();
+            this.host = this.bindHost();
+            this.key = documentKey;
+            this.geometry = geometry;
+            this.values.clear();
+            this.stats.loads++;
+            this.resize(widthPx, heightPx, density);
+        }
+        // A document's variables are in Remote Compose's `USER:` domain; set each by the name it declares.
+        const declared = this.host.variables();
+        for (const [name, value] of Object.entries(values)) {
+            const text = JSON.stringify(value);
+            if (this.values.get(name) === text)
+                continue;
+            const as = `USER:${name}` in declared ? `USER:${name}` : name;
+            if (!(as in declared))
+                continue; // the document doesn't read it
+            this.host.set(as, value);
+            this.values.set(name, text);
+            this.stats.sets++;
+        }
+        this.handle.player.repaint();
+        const measured = this.handle.player.measureSize();
+        this.measuredHeightDp = measured ? measured.height / density : undefined;
+    }
+    /** The canvas at [widthPx] × [heightPx] CSS pixels. */
+    resize(widthPx, heightPx, density) {
+        if (!this.disposed && widthPx > 0 && heightPx > 0)
+            this.handle.resize(Math.round(widthPx * density), Math.round(heightPx * density));
+    }
+    /** Forgets the document playing, so the next [show] loads its document again. */
+    forget() {
+        this.latest++;
+        this.epoch++;
+        this.key = undefined;
+        this.geometry = undefined;
+        this.values.clear();
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.latest++;
+        this.host.dispose();
+        this.handle.destroy();
+        void this.queue.then(() => this.handle.destroy(), () => this.handle.destroy());
+    }
+}
+function valueTypeOf(value) {
+    if (value === undefined || value === null)
+        return 'none';
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? 'int' : 'float';
+    return 'string';
+}

package/node_modules/@yschimke/livery-web/dist/preview.d.ts

@@ -0,0 +1,57 @@
+import { type NamedAction } from './player.js';
+import { type WebConfig, type Routed } from './session.js';
+export interface PreviewOptions {
+    /** Host-owned trust and capabilities. These cannot be supplied by the descriptor. */
+    config: Omit<WebConfig, 'catalog'>;
+    /** Minimal embeds retain theme/reset; full previews also expose width/examples. */
+    controls?: 'full' | 'minimal';
+    /** Developer diagnostics, hidden by public publication pages. */
+    showActionLog?: boolean;
+    fetch?: typeof fetch;
+    /** Host-provided example overrides; never application scripts. */
+    examples?: Record<string, Record<string, unknown>>;
+}
+/** Experimental fixture viewer. Each instance owns its data and its Wasm session. */
+export declare class ComponentPreview {
+    readonly element: HTMLElement;
+    private options;
+    private session?;
+    private player?;
+    private publication?;
+    private render?;
+    private data;
+    private sequence;
+    private disposed;
+    private inView;
+    private theme;
+    private width;
+    private readonly abort;
+    private readonly observer;
+    private readonly resizeObserver;
+    private renderedWidth;
+    private readonly surface;
+    private readonly status;
+    private readonly log;
+    private readonly controls;
+    private readonly visibility;
+    readonly ready: Promise<void>;
+    readonly actions: Routed[];
+    constructor(element: HTMLElement, url: string, options: PreviewOptions);
+    get values(): Record<string, unknown>;
+    get stats(): {
+        loads: number;
+        sets: number;
+    };
+    get state(): string;
+    private open;
+    /** Takes example data; the core binder, not this UI, decides whether it fits. */
+    setData(data: Record<string, unknown>): Promise<void>;
+    reset(): Promise<void>;
+    dispatch(action: NamedAction): Promise<void>;
+    private update;
+    private suspend;
+    dispose(): void;
+    private fail;
+    private setStatus;
+    private addControls;
+}

package/node_modules/@yschimke/livery-web/dist/preview.js

@@ -0,0 +1,214 @@
+import { descriptor, previewUrl } from './descriptor.js';
+import { RcCanvasPlayer } from './player.js';
+import { WebSession } from './session.js';
+const light = { primary: '#FF6750A4', onSurface: '#FF1D1B20', surface: '#FFF7F2FA' };
+const dark = { primary: '#FFD0BCFF', onSurface: '#FFE6E1E5', surface: '#FF211F26' };
+/** Experimental fixture viewer. Each instance owns its data and its Wasm session. */
+export class ComponentPreview {
+    constructor(element, url, options) {
+        this.element = element;
+        this.options = options;
+        this.data = {};
+        this.sequence = 0;
+        this.disposed = false;
+        this.inView = true;
+        this.theme = light;
+        this.width = 360;
+        this.abort = new AbortController();
+        this.renderedWidth = 0;
+        this.surface = document.createElement('div');
+        this.status = document.createElement('p');
+        this.log = document.createElement('pre');
+        this.controls = document.createElement('div');
+        this.visibility = () => {
+            if (document.hidden || !this.inView)
+                this.suspend();
+            else
+                void this.update();
+        };
+        this.actions = [];
+        const link = document.createElement('a');
+        link.href = new URL(url, location.href).href;
+        link.textContent = 'Open preview';
+        const title = document.createElement('h2');
+        title.textContent = 'Component preview';
+        this.status.setAttribute('role', 'status');
+        this.log.setAttribute('role', 'log');
+        this.log.setAttribute('aria-label', 'Preview actions');
+        this.surface.setAttribute('aria-label', 'Interactive Remote Compose component');
+        this.controls.style.cssText = 'display:flex;gap:12px;flex-wrap:wrap;margin:12px 0';
+        this.surface.style.maxWidth = '100%';
+        this.element.replaceChildren(title, link, this.controls, this.surface, this.status);
+        if (this.options.showActionLog !== false)
+            this.element.append(this.log);
+        this.addControls();
+        document.addEventListener('visibilitychange', this.visibility);
+        this.observer = new IntersectionObserver(entries => { this.inView = entries[0]?.isIntersecting ?? false; this.visibility(); });
+        this.observer.observe(element);
+        this.resizeObserver = new ResizeObserver(() => { if (this.surface.clientWidth !== this.renderedWidth)
+            void this.update(); });
+        this.resizeObserver.observe(this.surface);
+        this.ready = this.open(new URL(url, location.href).href, title, link);
+    }
+    get values() { return { ...this.data }; }
+    get stats() { return this.player ? { ...this.player.stats } : { loads: 0, sets: 0 }; }
+    get state() { return this.element.dataset.state ?? 'loading'; }
+    async open(url, title, link) {
+        this.setStatus('loading', 'Loading preview…');
+        try {
+            previewUrl(url);
+            const response = await (this.options.fetch ?? fetch)(url, { signal: this.abort.signal, credentials: 'omit', redirect: 'error' });
+            if (!response.ok)
+                throw new Error(`Preview unavailable (${response.status})`);
+            const bytes = await response.arrayBuffer();
+            if (bytes.byteLength > 64 * 1024)
+                throw new Error('Preview descriptor is too large');
+            const text = new TextDecoder().decode(bytes);
+            const pub = descriptor(JSON.parse(text), url);
+            if (this.disposed)
+                return;
+            this.publication = pub;
+            this.data = structuredClone(pub.data);
+            title.textContent = pub.fallback.title;
+            link.href = pub.canonicalUrl;
+            const opened = await WebSession.open({ ...this.options.config, catalog: new URL('./', pub.catalog.manifestUrl).href }, this.abort.signal);
+            if (this.disposed) {
+                opened.close();
+                return;
+            }
+            this.session = opened;
+            await this.update();
+        }
+        catch (error) {
+            if (!this.disposed)
+                this.fail(error);
+        }
+    }
+    /** Takes example data; the core binder, not this UI, decides whether it fits. */
+    async setData(data) { this.data = structuredClone(data); await this.update(); }
+    async reset() { if (this.publication) {
+        this.actions.length = 0;
+        this.log.textContent = '';
+        const example = this.controls.querySelector('[aria-label="Example"]');
+        if (example)
+            example.value = 'Default';
+        await this.setData(this.publication.data);
+    } }
+    async dispatch(action) {
+        const active = this.render, session = this.session;
+        if (this.disposed || !active || !session)
+            return;
+        const result = await session.action(active.render, action.name, action.valueType, action.value);
+        if (this.disposed || this.render !== active)
+            return;
+        this.actions.push(result);
+        this.log.textContent = this.actions.slice(-8).map(a => JSON.stringify(a)).join('\n');
+        if (result.route === 'set') {
+            this.data = { ...this.data, [result.input]: result.value };
+            await this.update();
+        }
+    }
+    async update() {
+        const session = this.session, pub = this.publication;
+        if (!session || !pub || this.disposed || document.hidden || !this.inView)
+            return;
+        this.surface.style.width = `${this.width}px`;
+        const effectiveWidth = Math.min(this.width, this.surface.clientWidth || this.width);
+        this.renderedWidth = effectiveWidth;
+        const mine = ++this.sequence;
+        const previous = this.render;
+        try {
+            const space = { widthDp: effectiveWidth, density: devicePixelRatio || 1, theme: this.theme, colorScheme: this.theme === dark ? 'dark' : 'light', decisionId: `preview:${pub.publicationId}` };
+            let r = await session.render(pub.template.contract, this.data, space, pub.template.designId, pub.template.sha256);
+            if (!r.ok && r.waiting && mine === this.sequence) {
+                this.setStatus('loading', 'Loading component resources…');
+                await session.fetchImages(); // explicitly outside the cache-only render
+                if (mine !== this.sequence || this.disposed)
+                    return;
+                r = await session.render(pub.template.contract, this.data, space, pub.template.designId, pub.template.sha256);
+            }
+            if (mine !== this.sequence || this.disposed) {
+                if (r.ok)
+                    session.release(r.render);
+                return;
+            }
+            if (!r.ok) {
+                this.suspend();
+                this.setStatus('fallback', `${pub.fallback.description} (${r.reason})`);
+                return;
+            }
+            if (r.sha256 !== pub.template.sha256 || r.design !== pub.template.designId) {
+                session.release(r.render);
+                throw new Error('Pinned component unavailable');
+            }
+            this.render = r;
+            this.surface.style.width = `${this.width}px`;
+            this.surface.style.height = `${r.heightDp ?? 120}px`;
+            this.player ??= new RcCanvasPlayer(this.surface, a => { void this.dispatch(a).catch(e => this.fail(e)); }, { reloadOnResize: true });
+            const shown = await this.player.show(r.documentKey, r.document, r.values, effectiveWidth, r.heightDp ?? 120, devicePixelRatio || 1);
+            if (mine === this.sequence && !this.disposed && shown) {
+                if (!previous || previous.documentKey !== r.documentKey)
+                    session.shown(r.render);
+                this.setStatus('ready', 'Interactive preview — changes stay in this preview.');
+            }
+            if (previous)
+                session.release(previous.render);
+        }
+        catch (error) {
+            if (previous)
+                session.release(previous.render);
+            if (mine === this.sequence && !this.disposed) {
+                this.suspend();
+                this.fail(error);
+            }
+        }
+    }
+    suspend() {
+        this.sequence++;
+        if (this.render)
+            this.session?.release(this.render.render);
+        this.render = undefined;
+        this.player?.dispose();
+        this.player = undefined;
+        this.surface.replaceChildren();
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.abort.abort();
+        this.observer.disconnect();
+        this.resizeObserver.disconnect();
+        document.removeEventListener('visibilitychange', this.visibility);
+        this.suspend();
+        this.session?.close();
+        this.session = undefined;
+        this.controls.replaceChildren();
+        this.setStatus('disposed', 'Preview closed');
+    }
+    fail(error) { this.setStatus('fallback', `${this.publication?.fallback.description ?? 'Preview unavailable'} — ${error instanceof Error ? error.message : String(error)}`); }
+    setStatus(state, text) { this.element.dataset.state = state; this.status.textContent = text; }
+    addControls() {
+        const select = (label, values, change) => {
+            const wrapper = document.createElement('label');
+            wrapper.textContent = `${label} `;
+            const field = document.createElement('select');
+            field.setAttribute('aria-label', label);
+            for (const value of values)
+                field.add(new Option(value, value));
+            field.addEventListener('change', () => change(field.value));
+            wrapper.append(field);
+            this.controls.append(wrapper);
+        };
+        select('Theme', ['Light', 'Dark'], value => { this.theme = value === 'Dark' ? dark : light; void this.update(); });
+        if (this.options.controls !== 'minimal')
+            select('Width', ['360', '280', '480'], value => { this.width = Number(value); void this.update(); });
+        if (this.options.controls !== 'minimal' && Object.keys(this.options.examples ?? {}).length)
+            select('Example', ['Default', ...Object.keys(this.options.examples ?? {})], value => { if (this.publication)
+                void this.setData({ ...this.publication.data, ...this.options.examples?.[value] }); });
+        const reset = document.createElement('button');
+        reset.textContent = 'Reset';
+        reset.addEventListener('click', () => { void this.reset(); });
+        this.controls.append(reset);
+    }
+}

package/node_modules/@yschimke/livery-web/dist/publication.d.ts

@@ -0,0 +1,7 @@
+import { ComponentPreview } from './preview.js';
+export interface PublicationViewer {
+    preview: ComponentPreview;
+    dispose(): void;
+}
+/** Enhances a server-rendered publication. Configuration belongs to the host, not the publication. */
+export declare function mountPublication(element: HTMLElement): PublicationViewer;

package/node_modules/@yschimke/livery-web/dist/publication.js

@@ -0,0 +1,103 @@
+import { ComponentPreview } from './preview.js';
+import { previewUrl } from './descriptor.js';
+const mounted = new WeakMap();
+/** Enhances a server-rendered publication. Configuration belongs to the host, not the publication. */
+export function mountPublication(element) {
+    const existing = mounted.get(element);
+    if (existing)
+        return existing;
+    const localUrl = (value, label) => {
+        if (!value)
+            throw new Error(`Missing ${label}`);
+        const url = previewUrl(new URL(value, document.baseURI).href);
+        if (url.origin !== location.origin)
+            throw new Error(`${label} must use the host origin`);
+        return url.href;
+    };
+    const source = localUrl(element.dataset.descriptor ?? document.querySelector('link[rel="alternate"][type="application/vnd.livery.preview+json"]')?.href, 'preview descriptor');
+    const canonical = localUrl(element.dataset.canonical ?? document.querySelector('link[rel="canonical"]')?.href, 'canonical URL');
+    const config = JSON.parse(element.dataset.config ?? '{}');
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        throw new Error('Invalid host configuration');
+    const mode = element.dataset.mode ?? 'page';
+    if (mode !== 'page' && mode !== 'embed')
+        throw new Error('Unsupported viewer mode');
+    const body = document.createElement('div');
+    body.className = 'livery-publication-component';
+    element.classList.add('livery-publication');
+    element.replaceChildren(body);
+    const preview = new ComponentPreview(body, source, { config, controls: mode === 'embed' ? 'minimal' : 'full', showActionLog: false });
+    const share = document.createElement('nav');
+    share.className = 'livery-publication-share';
+    share.setAttribute('aria-label', mode === 'embed' ? 'Full preview' : 'Share preview');
+    const status = document.createElement('p');
+    status.className = 'livery-share-status';
+    status.setAttribute('role', 'status');
+    let disposed = false;
+    const abort = new AbortController();
+    const say = (text) => { if (!disposed)
+        status.textContent = text; };
+    if (mode === 'embed') {
+        const open = document.createElement('a');
+        open.textContent = 'Open full preview';
+        open.href = canonical;
+        open.target = '_blank';
+        open.rel = 'noopener';
+        share.append(open);
+    }
+    else {
+        const bluesky = document.createElement('a');
+        bluesky.textContent = 'Share to Bluesky';
+        bluesky.href = `https://bsky.app/intent/compose?${new URLSearchParams({ text: canonical })}`;
+        bluesky.target = '_blank';
+        bluesky.rel = 'noopener noreferrer';
+        share.append(bluesky);
+        if (typeof navigator.share === 'function') {
+            const system = document.createElement('button');
+            system.type = 'button';
+            system.textContent = 'Share…';
+            system.addEventListener('click', () => {
+                // Invoke inside this click, before any await: transient activation must reach the OS sheet.
+                void navigator.share({ title: document.title, url: canonical }).then(() => say('Shared'), error => {
+                    say(error instanceof DOMException && error.name === 'AbortError' ? 'Share cancelled' : 'Sharing unavailable. Use Copy link instead.');
+                });
+            }, { signal: abort.signal });
+            share.append(system);
+        }
+        const copy = document.createElement('button');
+        copy.type = 'button';
+        copy.textContent = 'Copy link';
+        const manual = document.createElement('input');
+        manual.readOnly = true;
+        manual.value = canonical;
+        manual.hidden = true;
+        manual.setAttribute('aria-label', 'Preview link');
+        copy.addEventListener('click', () => {
+            const failed = () => { if (!disposed) {
+                manual.hidden = false;
+                manual.focus();
+                manual.select();
+                say('Select and copy the preview link.');
+            } };
+            if (!navigator.clipboard?.writeText) {
+                failed();
+                return;
+            }
+            void navigator.clipboard.writeText(canonical).then(() => say('Link copied'), failed);
+        }, { signal: abort.signal });
+        share.append(copy, manual);
+    }
+    element.append(share, status);
+    const viewer = { preview, dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            abort.abort();
+            preview.dispose();
+            share.remove();
+            status.remove();
+            mounted.delete(element);
+        } };
+    mounted.set(element, viewer);
+    return viewer;
+}

package/node_modules/@yschimke/livery-web/dist/session.d.ts

@@ -0,0 +1,71 @@
+export interface WebConfig {
+    catalog: string;
+    keys?: {
+        keyId: string;
+        publicKey: string;
+        contracts?: string[];
+    }[];
+    /** Development only. A descriptor cannot opt its own host into this policy. */
+    unsigned?: boolean;
+    capabilities?: {
+        surface: string;
+        maxRcApiLevel: number;
+        profiles: string[];
+        features?: string[];
+        maxBytes?: number;
+    };
+    imageHosts?: string[];
+    urlAllowlist?: string[];
+    appKinds?: string[];
+}
+export interface Space {
+    colorScheme?: string;
+    widthDp?: number;
+    heightDp?: number;
+    density?: number;
+    theme?: Record<string, string>;
+    decisionId?: string;
+}
+export type Ready = {
+    ok: true;
+    render: number;
+    document: Uint8Array;
+    documentKey: string;
+    values: Record<string, string | number>;
+    design: string;
+    sha256: string;
+    heightDp?: number;
+};
+export type Rendered = Ready | {
+    ok: false;
+    waiting?: boolean;
+    reason: string;
+};
+export type Routed = {
+    route: 'set';
+    input: string;
+    value: unknown;
+} | {
+    route: 'app';
+    kind: string;
+    action: string;
+    args: Record<string, string>;
+} | {
+    route: 'dropped';
+    reason: string;
+};
+/** Typed transport only: selection, binding and action validation happen in Kotlin. */
+export declare class WebSession {
+    private lib;
+    readonly id: number;
+    private closed;
+    private constructor();
+    static open(config: WebConfig, signal?: AbortSignal): Promise<WebSession>;
+    render(contract: string, data: Record<string, unknown>, space: Space, design?: string, sha?: string): Promise<Rendered>;
+    action(render: number, name: string, type: string, value: unknown): Promise<Routed>;
+    fetchImages(): Promise<boolean>;
+    shown(render: number): void;
+    release(render: number): void;
+    close(): void;
+    private check;
+}

package/node_modules/@yschimke/livery-web/dist/session.js

@@ -0,0 +1,55 @@
+let loading;
+function module() {
+    const url = new URL('./livery-web/livery-livery-web-core.mjs', import.meta.url).href;
+    return loading ??= import(/* @vite-ignore */ url);
+}
+/** Typed transport only: selection, binding and action validation happen in Kotlin. */
+export class WebSession {
+    constructor(lib, id) {
+        this.lib = lib;
+        this.id = id;
+        this.closed = false;
+    }
+    static async open(config, signal) {
+        const lib = await module();
+        signal?.throwIfAborted();
+        const id = lib.previewCreate(JSON.stringify(config));
+        const close = () => lib.previewClose(id);
+        signal?.addEventListener('abort', close, { once: true });
+        try {
+            await lib.previewConnect(id);
+            signal?.throwIfAborted();
+            return new WebSession(lib, id);
+        }
+        catch (error) {
+            close();
+            throw error;
+        }
+        finally {
+            signal?.removeEventListener('abort', close);
+        }
+    }
+    async render(contract, data, space, design, sha) {
+        this.check();
+        const r = JSON.parse(String(await this.lib.previewRender(this.id, contract, JSON.stringify(data), JSON.stringify(space), design ?? null, sha ?? null)));
+        if (r.ok)
+            r.document = Uint8Array.from(atob(r.document), c => c.charCodeAt(0));
+        return r;
+    }
+    async action(render, name, type, value) {
+        if (this.closed)
+            return { route: 'dropped', reason: 'preview disposed' };
+        return JSON.parse(String(await this.lib.previewAction(this.id, render, name, type, value == null ? null : String(value))));
+    }
+    async fetchImages() { this.check(); return String(await this.lib.previewFetchImages(this.id)) === 'true'; }
+    shown(render) { if (!this.closed)
+        this.lib.previewShown(this.id, render); }
+    release(render) { if (!this.closed)
+        this.lib.previewRelease(this.id, render); }
+    close() { if (!this.closed) {
+        this.closed = true;
+        this.lib.previewClose(this.id);
+    } }
+    check() { if (this.closed)
+        throw new Error('preview disposed'); }
+}

package/node_modules/@yschimke/livery-web/dist/viewer.d.ts

@@ -0,0 +1 @@
+export { mountPublication } from './publication.js';

package/node_modules/@yschimke/livery-web/dist/viewer.js

@@ -0,0 +1,18 @@
+import { mountPublication } from './publication.js';
+const viewers = [];
+for (const element of document.querySelectorAll('[data-livery-preview]')) {
+    try {
+        viewers.push(mountPublication(element));
+    }
+    catch (error) {
+        element.dataset.state = 'fallback';
+        const message = document.createElement('p');
+        message.setAttribute('role', 'status');
+        message.textContent = `Interactive preview unavailable — ${error instanceof Error ? error.message : String(error)}`;
+        element.replaceChildren(message);
+    }
+}
+// Browsers retain the document in the back/forward cache; its visibility handler pauses playback.
+window.addEventListener('pagehide', event => { if (!event.persisted)
+    viewers.forEach(viewer => viewer.dispose()); });
+export { mountPublication } from './publication.js';