@yschimke/livery-a2ui 0.0.0-stage → 0.11.0

package/node_modules/@js-joda/core/src/zone/ZoneRules.js

@@ -0,0 +1,464 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {requireNonNull, abstractMethodFail} from '../assert';
+
+import {Duration} from '../Duration';
+import {Instant} from '../Instant';
+
+export class ZoneRules {
+
+    /**
+     * Obtains an instance of {@link ZoneRules} that always uses the same offset.
+     *
+     * The returned rules always have the same offset.
+     *
+     * @param {ZoneOffset} offset - the offset, not null
+     * @return {ZoneRules} the zone rules, not null
+     */
+    static of(offset) {
+        requireNonNull(offset, 'offset');
+        return new Fixed(offset);
+    }
+
+
+    //-----------------------------------------------------------------------
+    /**
+     * Checks of the zone rules are fixed, such that the offset never varies.
+     *
+     * @return {boolean} true if the time-zone is fixed and the offset never changes
+     */
+    isFixedOffset(){
+        abstractMethodFail('ZoneRules.isFixedOffset');
+    }
+
+    //-----------------------------------------------------------------------
+
+    /**
+     *
+     * @param instantOrLocalDateTime
+     * @returns {ZoneOffset}
+     */
+    offset(instantOrLocalDateTime){
+        if(instantOrLocalDateTime instanceof Instant){
+            return this.offsetOfInstant(instantOrLocalDateTime);
+        } else {
+            return this.offsetOfLocalDateTime(instantOrLocalDateTime);
+        }
+    }
+
+    /**
+     * Gets the offset applicable at the specified instant in these rules.
+     *
+     * The mapping from an instant to an offset is simple, there is only
+     * one valid offset for each instant.
+     * This method returns that offset.
+     *
+     * @param {Instant} instant - the instant to find the offset for, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffset} the offset, not null
+     */
+    // eslint-disable-next-line no-unused-vars
+    offsetOfInstant(instant){
+        abstractMethodFail('ZoneRules.offsetInstant');
+    }
+
+    /**
+     * Gets the offset applicable at the specified epochMilli in these rules.
+     *
+     * The method is for javascript performance optimisation.
+     *
+     * @param {number} epochMilli - the epoch millisecond to find the offset for, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffset} the offset, not null
+     */
+    // eslint-disable-next-line no-unused-vars
+    offsetOfEpochMilli(epochMilli){
+        abstractMethodFail('ZoneRules.offsetOfEpochMilli');
+    }
+
+
+    /**
+     * Gets a suitable offset for the specified local date-time in these rules.
+     *
+     * The mapping from a local date-time to an offset is not straightforward.
+     * There are three cases:
+     *
+     * * Normal, with one valid offset. For the vast majority of the year, the normal
+     *   case applies, where there is a single valid offset for the local date-time.
+     * * Gap, with zero valid offsets. This is when clocks jump forward typically
+     *   due to the spring daylight savings change from "winter" to "summer".
+     *   In a gap there are local date-time values with no valid offset.
+     * * Overlap, with two valid offsets. This is when clocks are set back typically
+     *   due to the autumn daylight savings change from "summer" to "winter".
+     *   In an overlap there are local date-time values with two valid offsets.
+     *
+     * Thus, for any given local date-time there can be zero, one or two valid offsets.
+     * This method returns the single offset in the Normal case, and in the Gap or Overlap
+     * case it returns the offset before the transition.
+     *
+     * Since, in the case of Gap and Overlap, the offset returned is a "best" value, rather
+     * than the "correct" value, it should be treated with care. Applications that care
+     * about the correct offset should use a combination of this method,
+     * {@link getValidOffsets} and {@link getTransition}.
+     *
+     * @param {LocalDateTime} localDateTime - the local date-time to query, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffset} the best available offset for the local date-time, not null
+     */
+    // eslint-disable-next-line no-unused-vars
+    offsetOfLocalDateTime(localDateTime){
+        abstractMethodFail('ZoneRules.offsetLocalDateTime');
+    }
+
+    /**
+     * Gets the offset applicable at the specified local date-time in these rules.
+     *
+     * The mapping from a local date-time to an offset is not straightforward.
+     * There are three cases:
+     *
+     * * Normal, with one valid offset. For the vast majority of the year, the normal
+     *   case applies, where there is a single valid offset for the local date-time.
+     * * Gap, with zero valid offsets. This is when clocks jump forward typically
+     *   due to the spring daylight savings change from "winter" to "summer".
+     *   In a gap there are local date-time values with no valid offset.
+     * * Overlap, with two valid offsets. This is when clocks are set back typically
+     *   due to the autumn daylight savings change from "summer" to "winter".
+     *   In an overlap there are local date-time values with two valid offsets.
+     *
+     * Thus, for any given local date-time there can be zero, one or two valid offsets.
+     * This method returns that list of valid offsets, which is a list of size 0, 1 or 2.
+     * In the case where there are two offsets, the earlier offset is returned at index 0
+     * and the later offset at index 1.
+     *
+     * There are various ways to handle the conversion from a {@link LocalDateTime}.
+     * One technique, using this method, would be:
+     * <pre>
+     *  List<ZoneOffset> validOffsets = rules.getOffset(localDT);
+     *  if (validOffsets.size() == 1) {
+     *    // Normal case: only one valid offset
+     *    zoneOffset = validOffsets.get(0);
+     *  } else {
+     *    // Gap or Overlap: determine what to do from transition (which will be non-null)
+     *    ZoneOffsetTransition trans = rules.getTransition(localDT);
+     *  }
+     * </pre>
+     *
+     * In theory, it is possible for there to be more than two valid offsets.
+     * This would happen if clocks to be put back more than once in quick succession.
+     * This has never happened in the history of time-zones and thus has no special handling.
+     * However, if it were to happen, then the list would return more than 2 entries.
+     *
+     * @param {LocalDateTime} localDateTime - the local date-time to query for valid offsets, not null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffset[]} the list of valid offsets, may be immutable, not null
+     */
+    // eslint-disable-next-line no-unused-vars
+    validOffsets(localDateTime){
+        abstractMethodFail('ZoneRules.validOffsets');
+    }
+
+    /**
+     * Gets the offset transition applicable at the specified local date-time in these rules.
+     *
+     * The mapping from a local date-time to an offset is not straightforward.
+     * There are three cases:
+     *
+     * * Normal, with one valid offset. For the vast majority of the year, the normal
+     *   case applies, where there is a single valid offset for the local date-time.
+     * * Gap, with zero valid offsets. This is when clocks jump forward typically
+     *   due to the spring daylight savings change from "winter" to "summer".
+     *   In a gap there are local date-time values with no valid offset.
+     * * Overlap, with two valid offsets. This is when clocks are set back typically
+     *   due to the autumn daylight savings change from "summer" to "winter".
+     *   In an overlap there are local date-time values with two valid offsets.
+     *
+     * A transition is used to model the cases of a Gap or Overlap.
+     * The Normal case will return null.
+     *
+     * There are various ways to handle the conversion from a {@link LocalDateTime}.
+     * One technique, using this method, would be:
+     * <pre>
+     *  ZoneOffsetTransition trans = rules.getTransition(localDT);
+     *  if (trans != null) {
+     *    // Gap or Overlap: determine what to do from transition
+     *  } else {
+     *    // Normal case: only one valid offset
+     *    zoneOffset = rule.getOffset(localDT);
+     *  }
+     * </pre>
+     *
+     * @param {LocalDateTime} localDateTime  the local date-time to query for offset transition, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffsetTransition} the offset transition, null if the local date-time is not in transition
+     */
+    // eslint-disable-next-line no-unused-vars
+    transition(localDateTime){
+        abstractMethodFail('ZoneRules.transition');
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Gets the standard offset for the specified instant in this zone.
+     *
+     * This provides access to historic information on how the standard offset
+     * has changed over time.
+     * The standard offset is the offset before any daylight saving time is applied.
+     * This is typically the offset applicable during winter.
+     *
+     * @param {Instant} instant - the instant to find the offset information for, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffset} the standard offset, not null
+     */
+    // eslint-disable-next-line no-unused-vars
+    standardOffset(instant){
+        abstractMethodFail('ZoneRules.standardOffset');
+    }
+
+    /**
+     * Gets the amount of daylight savings in use for the specified instant in this zone.
+     *
+     * This provides access to historic information on how the amount of daylight
+     * savings has changed over time.
+     * This is the difference between the standard offset and the actual offset.
+     * Typically the amount is zero during winter and one hour during summer.
+     * Time-zones are second-based, so the nanosecond part of the duration will be zero.
+     *
+     * @param {Instant} instant - the instant to find the daylight savings for, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {Duration} the difference between the standard and actual offset, not null
+     */
+    // eslint-disable-next-line no-unused-vars
+    daylightSavings(instant){
+        abstractMethodFail('ZoneRules.daylightSavings');
+        //    default {
+        //        ZoneOffset standardOffset = getStandardOffset(instant);
+        //        ZoneOffset actualOffset = getOffset(instant);
+        //        return actualOffset.toDuration().minus(standardOffset.toDuration()).normalized();
+        //    }
+    }
+
+    /**
+     * Checks if the specified instant is in daylight savings.
+     *
+     * This checks if the standard and actual offsets are the same at the specified instant.
+     *
+     * @param {Instant} instant - the instant to find the offset information for, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {boolean} the standard offset, not null
+     */
+    // eslint-disable-next-line no-unused-vars
+    isDaylightSavings(instant) {
+        abstractMethodFail('ZoneRules.isDaylightSavings');
+        //    default {
+        //        return (getStandardOffset(instant).equals(getOffset(instant)) == false);
+        //    }
+    }
+
+    /**
+     * Checks if the offset date-time is valid for these rules.
+     *
+     * To be valid, the local date-time must not be in a gap and the offset
+     * must match the valid offsets.
+     *
+     * @param {LocalDateTime} localDateTime - the date-time to check, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @param {ZoneOffset} offset - the offset to check, null returns false
+     * @return {boolean} true if the offset date-time is valid for these rules
+     */
+    // eslint-disable-next-line no-unused-vars
+    isValidOffset(localDateTime, offset){
+        abstractMethodFail('ZoneRules.isValidOffset');
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Gets the next transition after the specified instant.
+     *
+     * This returns details of the next transition after the specified instant.
+     * For example, if the instant represents a point where "Summer" daylight savings time
+     * applies, then the method will return the transition to the next "Winter" time.
+     *
+     * @param {Instant} instant - the instant to get the next transition after, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffsetTransition} the next transition after the specified instant, null if this is after the last transition
+     */
+    // eslint-disable-next-line no-unused-vars
+    nextTransition(instant){
+        abstractMethodFail('ZoneRules.nextTransition');
+    }
+
+    /**
+     * Gets the previous transition before the specified instant.
+     *
+     * This returns details of the previous transition after the specified instant.
+     * For example, if the instant represents a point where "summer" daylight saving time
+     * applies, then the method will return the transition from the previous "winter" time.
+     *
+     * @param {Instant} instant - the instant to get the previous transition after, not null, but null
+     *  may be ignored if the rules have a single offset for all instants
+     * @return {ZoneOffsetTransition} the previous transition after the specified instant, null if this is before the first transition
+     */
+    // eslint-disable-next-line no-unused-vars
+    previousTransition(instant){
+        abstractMethodFail('ZoneRules.previousTransition');
+    }
+
+    /**
+     * Gets the complete list of fully defined transitions.
+     *
+     * The complete set of transitions for this rules instance is defined by this method
+     * and {@link getTransitionRules}. This method returns those transitions that have
+     * been fully defined. These are typically historical, but may be in the future.
+     *
+     * The list will be empty for fixed offset rules and for any time-zone where there has
+     * only ever been a single offset. The list will also be empty if the transition rules are unknown.
+     *
+     * @return {ZoneOffsetTransition[]} an immutable list of fully defined transitions, not null
+     */
+    transitions(){
+        abstractMethodFail('ZoneRules.transitions');
+    }
+
+    /**
+     * Gets the list of transition rules for years beyond those defined in the transition list.
+     *
+     * The complete set of transitions for this rules instance is defined by this method
+     * and {@link getTransitions}. This method returns instances of {@link ZoneOffsetTransitionRule}
+     * that define an algorithm for when transitions will occur.
+     *
+     * For any given {@link ZoneRules}, this list contains the transition rules for years
+     * beyond those years that have been fully defined. These rules typically refer to future
+     * daylight saving time rule changes.
+     *
+     * If the zone defines daylight savings into the future, then the list will normally
+     * be of size two and hold information about entering and exiting daylight savings.
+     * If the zone does not have daylight savings, or information about future changes
+     * is uncertain, then the list will be empty.
+     *
+     * The list will be empty for fixed offset rules and for any time-zone where there is no
+     * daylight saving time. The list will also be empty if the transition rules are unknown.
+     *
+     * @return {ZoneOffsetTransitionRule[]} an immutable list of transition rules, not null
+     */
+    transitionRules(){
+        abstractMethodFail('ZoneRules.transitionRules');
+    }
+
+    toString(){
+        abstractMethodFail('ZoneRules.toString');
+    }
+
+    /**
+     * toJSON() use by JSON.stringify
+     * delegates to toString()
+     *
+     * @return {string}
+     */
+    toJSON() {
+        return this.toString();
+    }
+}
+
+
+class Fixed extends ZoneRules{
+    /**
+     *
+     * @param {ZoneOffset} offset
+     * @private
+     */
+    constructor(offset){
+        super();
+        this._offset = offset;
+    }
+
+    isFixedOffset(){
+        return true;
+    }
+
+    offsetOfInstant(){
+        return this._offset;
+    }
+
+    offsetOfEpochMilli(){
+        return this._offset;
+    }
+
+    offsetOfLocalDateTime(){
+        return this._offset;
+    }
+
+    validOffsets(){
+        return [this._offset];
+    }
+
+    transition(){
+        return null;
+    }
+
+    standardOffset(){
+        return this._offset;
+    }
+
+    daylightSavings(){
+        return Duration.ZERO;
+    }
+
+    isDaylightSavings(){
+        return false;
+    }
+
+    /**
+     *
+     * @param {LocalDateTime} localDateTime
+     * @param {ZoneOffset} offset
+     * @return {boolean}
+     */
+    isValidOffset(localDateTime, offset) {
+        return this._offset.equals(offset);
+    }
+
+    nextTransition(){
+        return null;
+    }
+
+    previousTransition(){
+        return null;
+    }
+
+    transitions(){
+        return [];
+    }
+
+    transitionRules(){
+        return [];
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     *
+     * @param {*} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof Fixed) {
+            return this._offset.equals(other._offset);
+        }
+        return false;
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    toString() {
+        return 'FixedRules:' + this._offset.toString();
+    }
+
+}

package/node_modules/@js-joda/core/src/zone/ZoneRulesProvider.js

@@ -0,0 +1,36 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter, Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {DateTimeException} from '../errors';
+
+export class ZoneRulesProvider {
+    /**
+     * Gets the rules for the zone ID.
+     *
+     * This returns the latest available rules for the zone ID.
+     *
+     * This method relies on time-zone data provider files that are configured.
+     *
+     * @param {string} zoneId
+     * @return {ZoneRules}
+     */
+    static getRules(zoneId){
+        throw new DateTimeException('unsupported ZoneId:' + zoneId);
+    }
+
+
+    /**
+     * Gets the set of available zone IDs.
+     *
+     * These zone IDs are loaded and available for use by {@link ZoneId}.
+     *
+     * @return {string[]} a modifiable copy of the set of zone IDs, not null
+     */
+    static getAvailableZoneIds(){
+        return [];
+    }
+}
+

package/node_modules/@yschimke/livery-web/README.md

@@ -0,0 +1,112 @@
+# @yschimke/livery-web: standalone component preview (experimental)
+
+A browser RC player and local component-preview host using Livery's Kotlin/Wasm
+selection, binding, trust and action gates. No A2UI or UI Builder runtime is required.
+The first fixture is the quantity stepper in `samples/two-way`; Confetti integration
+is deferred. This includes an experimental viewer distribution for a host to serve; it does not
+deploy a hosting service.
+The standalone npm package is currently built from source, not published independently.
+A successful future release also attaches a `livery-preview-viewer-<version>.zip`.
+A draft or failed release does not establish public artifact availability.
+
+## Run
+
+From the repository root:
+
+```sh
+./gradlew :livery-web-core:webDist :livery-publish:installDist :livery-capture-cmp:sampleCatalogs
+cd web/core
+npm ci
+npm run build
+npm test
+npm run demo
+```
+
+The demo command prints a loopback URL. It builds the sample catalog and stages
+`samples/component-preview/preview.json`; two players deliberately have independent
+state. The UI offers examples, light/dark theme, width, reset and the checked action log.
+No edit is published and no account state is changed.
+
+Tests use Playwright. Install its Chromium with `npx playwright install chromium`,
+or set `CHROMIUM_EXECUTABLE_PATH` to a compatible existing Chromium executable.
+Set `LIVERY_RENDER_OUT` to save a screenshot from the actual browser test.
+
+## Embed
+
+```ts
+import { ComponentPreview } from '@yschimke/livery-web';
+
+const preview = new ComponentPreview(container, descriptorUrl, {
+  config: {
+    keys: [{ keyId: 'publisher', publicKey: '<base64 Ed25519 key>' }],
+  },
+});
+await preview.ready;
+// Later, when removing the host:
+preview.dispose();
+```
+
+`unsigned: true` is used only by the local sample. Publisher trust, allowed action
+kinds, image hosts and player capabilities are host configuration, never descriptor
+permissions. The experimental descriptor is version 1, preview mode only, same-origin
+HTTPS references (HTTP only on loopback for development), and an exact design/hash pin. Unknown versions, rejected trust,
+unavailable pins and invalid data retain a readable fallback. This is not yet a
+portable publication standard or support for following a mutable “latest” channel.
+
+`ComponentPreview` is a DOM host, not a custom element. `WebSession` exposes the typed
+Wasm bridge and `RcCanvasPlayer` the neutral canvas player for other hosts. The preview
+accepts host-provided `examples` as input overrides. `controls: "minimal"` keeps
+theme/reset only; `showActionLog: false` hides developer action diagnostics. Every resulting dataset and `set`
+action passes through the Kotlin gates; TypeScript does not duplicate their rules.
+
+Each viewer owns its session/data. Closing it cancels session work, closes its HTTP
+client, removes observers/listeners and destroys its player. Offscreen/background
+players are destroyed and recreated from retained local values when visible; a pending
+one-shot resource fetch may finish while offscreen. Rendering itself is cache-only,
+with missing resource downloads performed separately. Data/theme changes keep the
+document when its document key is unchanged. Geometry changes reload the same bytes because
+the vendored player otherwise retains stale click regions after reflow. Image/long-value changes can require new
+bytes; removing a bound value reloads to restore the document's default.
+
+The effective host width participates in selection, not just canvas scaling. A host
+narrower than a compatible template gets fallback. The implementation has not established
+screen-reader semantics for the drawn RC controls, custom catalog-font support, or broad
+operation parity across players. Keep text/link fallback and do not advertise unsupported
+capabilities. The default standalone document budget is 256 KiB; hosts can configure it.
+
+## Existing A2UI adapter
+
+`web/a2ui` depends on this package's player, while its optional `livery-web` Wasm
+facade delegates shared work to `livery-web-core`. Build the core package before
+installing/building the local A2UI package. A2UI bundles its player dependency so
+installed tarball consumers do not need a sibling checkout. After changing the
+core package locally, rerun `npm ci` in `web/a2ui` to refresh its installed copy. Its existing component API remains intact.
+The checked-in vendor player and provenance now live in `web/core/vendor/`.
+
+## Distribute a publication viewer
+
+After `npm run build`, run `npm run bundle`. This produces `viewer-dist/` and
+`build/livery-preview-viewer-development.zip`, including the player, Kotlin/Wasm,
+styles, provenance, license and an asset inventory. Set `LIVERY_VIEWER_VERSION` to
+label a build. The runtime is self-contained; a host does not need npm, an import
+map, A2UI or a Livery checkout. Mount the directory at `/assets/livery-preview/`
+and generate publication HTML using [HOSTING.md](HOSTING.md)'s exact bootstrap
+attributes. Host-owned keys remain separate from publication data.
+
+The full-page viewer offers Bluesky's ordinary compose intent, system sharing where
+supported, and clipboard/manual copying. Each shares the canonical revision URL,
+without local edits or automatic posting. Embed mode retains theme/reset and a link
+to the full page. Server-rendered metadata, static fallback, descriptor discovery,
+publication storage and iframe policy belong to the host.
+
+`npm run test:viewer` extracts the ZIP and runs real Chromium/RC interaction under
+a revision URL and same-origin CSP, including share activation, denied/unsupported
+APIs, embed mode, trust failure and no-JavaScript fallback. It requires the built
+publisher CLI; `LIVERY_CLI` can point to an already installed CLI. To keep the local
+fixture server open for inspection, run `node test/viewer.mjs --serve`.
+
+For a separately running publication server with the quantity-stepper fixture,
+`LIVERY_PUBLICATION_URL=http://127.0.0.1:8080/p/quantity-stepper/r/fixture-1/ npm run test:host`
+checks actual SSR/discovery/thumbnail routes, desktop/mobile interaction and embed
+mode. It does not start a server or build another repository. `LIVERY_RENDER_OUT`
+saves screenshots from both browser test modes.

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

@@ -0,0 +1,24 @@
+/** Experimental sample descriptor, not a published protocol. Trust is configured by the host. */
+export interface PreviewDescriptor {
+    schemaVersion: 1;
+    mode: 'preview';
+    publicationId: string;
+    revision: string;
+    canonicalUrl: string;
+    catalog: {
+        manifestUrl: string;
+    };
+    template: {
+        contract: string;
+        designId: string;
+        sha256: string;
+    };
+    data: Record<string, unknown>;
+    fallback: {
+        title: string;
+        description: string;
+    };
+}
+/** The prototype permits plaintext transport only for its loopback development server. */
+export declare function previewUrl(source: string): URL;
+export declare function descriptor(value: unknown, source: string): PreviewDescriptor;

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

@@ -0,0 +1,32 @@
+function record(value) { return !!value && typeof value === 'object' && !Array.isArray(value); }
+/** The prototype permits plaintext transport only for its loopback development server. */
+export function previewUrl(source) {
+    const url = new URL(source);
+    const local = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+    if (url.username || url.password || (url.protocol !== 'https:' && !(url.protocol === 'http:' && local)))
+        throw new Error('Previews require HTTPS (or loopback development)');
+    return url;
+}
+export function descriptor(value, source) {
+    if (!record(value) || value.schemaVersion !== 1 || value.mode !== 'preview')
+        throw new Error('Unsupported preview format');
+    if (!record(value.catalog) || !record(value.template) || !record(value.data) || !record(value.fallback))
+        throw new Error('Incomplete preview');
+    for (const s of [value.publicationId, value.revision, value.canonicalUrl, value.catalog.manifestUrl, value.template.contract, value.template.designId, value.fallback.title, value.fallback.description]) {
+        if (typeof s !== 'string' || !s.length)
+            throw new Error('Invalid preview field');
+    }
+    if (typeof value.template.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(value.template.sha256))
+        throw new Error('Invalid template hash');
+    const base = previewUrl(source);
+    const resolve = (v) => {
+        const url = new URL(String(v), base);
+        if (!['http:', 'https:'].includes(url.protocol) || url.origin !== base.origin || url.username || url.password)
+            throw new Error('Preview URLs must use the host origin');
+        return url.href;
+    };
+    const canonicalUrl = resolve(value.canonicalUrl), manifestUrl = resolve(value.catalog.manifestUrl);
+    if (!new URL(manifestUrl).pathname.endsWith('/manifest.json'))
+        throw new Error('Expected a catalog manifest');
+    return { ...value, canonicalUrl, catalog: { manifestUrl } };
+}

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

@@ -0,0 +1,9 @@
+export { RcCanvasPlayer } from './player.js';
+export type { NamedAction } from './player.js';
+export { WebSession } from './session.js';
+export type { WebConfig, Space, Rendered, Routed } from './session.js';
+export { ComponentPreview } from './preview.js';
+export { descriptor } from './descriptor.js';
+export type { PreviewDescriptor } from './descriptor.js';
+export { mountPublication } from './publication.js';
+export type { PublicationViewer } from './publication.js';

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

@@ -0,0 +1,5 @@
+export { RcCanvasPlayer } from './player.js';
+export { WebSession } from './session.js';
+export { ComponentPreview } from './preview.js';
+export { descriptor } from './descriptor.js';
+export { mountPublication } from './publication.js';