@roxyapi/ui 0.9.0 → 0.11.0

package/src/utils/angel-sections.ts

@@ -0,0 +1,38 @@
+/**
+ * Ordered angel-number interpretation sections, shared by the angel-number card and lookup components so the field list, labels, and display order live in one place instead of being duplicated per component.
+ *
+ * @remarks The life-area keys (`spiritual`, `love`, `career`, `money`, `twinFlame`) mirror the `meaning` object in the angel-numbers OpenAPI response; `biblical` and `shadow` are top-level siblings present only on a known meaning, not on the digit-root fallback. Any absent field is skipped, so the one builder serves a full known meaning and the leaner digit-root reading alike.
+ */
+
+export interface MeaningSection {
+	label: string;
+	body: string;
+}
+
+const LIFE_AREA_SECTIONS: ReadonlyArray<{ key: string; label: string }> = [
+	{ key: 'spiritual', label: 'Spiritual' },
+	{ key: 'love', label: 'Love' },
+	{ key: 'career', label: 'Career' },
+	{ key: 'money', label: 'Money' },
+	{ key: 'twinFlame', label: 'Twin flame' },
+];
+
+/**
+ * Build the present-only interpretation sections in canonical order: the life areas first, then the optional `biblical` and `shadow` readings. An empty or missing field is omitted so the caller can render whatever the response actually carries.
+ */
+export function buildMeaningSections(
+	meaning: Record<string, string> | undefined,
+	biblical?: string,
+	shadow?: string,
+): MeaningSection[] {
+	const sections: MeaningSection[] = [];
+	if (meaning) {
+		for (const s of LIFE_AREA_SECTIONS) {
+			const body = meaning[s.key];
+			if (body) sections.push({ label: s.label, body });
+		}
+	}
+	if (biblical) sections.push({ label: 'Biblical', body: biblical });
+	if (shadow) sections.push({ label: 'Shadow', body: shadow });
+	return sections;
+}

package/src/utils/base-element.ts

@@ -0,0 +1,183 @@
+import {
+	type CSSResultGroup,
+	html,
+	LitElement,
+	type PropertyValues,
+} from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
+import { baseStyles } from './base-styles.js';
+import { buildRequest, FetchController } from './fetch-controller.js';
+import { MarkupDataController } from './markup-data.js';
+
+/**
+ * Shared base for every data-driven Roxy component. Consolidates the things every component used to repeat by hand and adds the self-contained, drop-in behavior: controlled-mode hydration, an opt-in self-fetch (form, request, loading, error, empty), the typed `data` slot, and the render switch. A subclass implements one method, {@link RoxyDataElement.renderData}.
+ *
+ * @remarks
+ * Two render modes, one component, which is the whole drop-in contract:
+ *
+ * - Controlled: a server (WordPress, JSX SSR, static HTML) fetches the response and injects it as a direct-child `<script type="application/json" class="roxy-data">`. {@link MarkupDataController} hydrates `data` from it on connect. No key reaches the browser. This is the path the WordPress plugin drives, and it is unchanged by the base class.
+ * - Uncontrolled: no data is injected, but a `data-endpoint` and a `pk_` `publishable-key` are set. The component renders its own `<roxy-endpoint-form>` (an internal detail, never placed by the consumer), and on submit fetches through {@link FetchController}, which refuses any non-publishable key. The result populates `data` and the component renders it.
+ *
+ * The JavaScript `data` property always wins over markup, so a host that assigns `el.data = …` after upgrade is authoritative.
+ *
+ * Self-fetch needs `<roxy-endpoint-form>` (and `<roxy-location-search>`) registered. The CDN bundle and the full `@roxyapi/ui` entry register everything; per-component ESM consumers that want self-fetch import the form component too.
+ *
+ * @example
+ * ```ts
+ * @customElement('roxy-dream-card')
+ * export class RoxyDreamCard extends RoxyDataElement<GetDreamSymbolResponse> {
+ *   static styles = [baseStyles, css`.card { … }`];
+ *   protected renderData(d: GetDreamSymbolResponse) {
+ *     return html`<article class="card">…</article>`;
+ *   }
+ *   protected renderEmpty() {
+ *     return html`<div class="roxy-empty" role="status">No dream symbol</div>`;
+ *   }
+ * }
+ * ```
+ */
+export abstract class RoxyDataElement<T = unknown> extends LitElement {
+	static styles: CSSResultGroup = [baseStyles];
+
+	/** Typed RoxyAPI response. Assigned in JavaScript, hydrated from the roxy-data island, or set by a self-fetch. */
+	@property({ attribute: false })
+	data: T | null = null;
+
+	/** Endpoint path for self-fetch, e.g. "astrology/natal-chart" or "dreams/symbols/{id}". Empty disables self-fetch (controlled mode only). */
+	@property({ type: String, attribute: 'data-endpoint' })
+	endpoint = '';
+
+	/** HTTP method for self-fetch. */
+	@property({ type: String })
+	method: 'GET' | 'POST' = 'POST';
+
+	/** Browser-safe publishable key (pk_) for self-fetch. A secret key is refused client-side. */
+	@property({ type: String, attribute: 'publishable-key' })
+	publishableKey?: string;
+
+	/** Override the API origin for self-hosted or proxied deployments. */
+	@property({ type: String, attribute: 'base-url' })
+	baseUrl?: string;
+
+	/** Override the OpenAPI spec URL the self-fetch form introspects. */
+	@property({ type: String, attribute: 'spec-url' })
+	specUrl?: string;
+
+	/** Consumer backend route that proxies the request (holds the secret key). When set, self-fetch POSTs the request here instead of calling RoxyAPI directly, so no key reaches the browser. The server-rendered (WordPress) path. */
+	@property({ type: String, attribute: 'submit-url' })
+	submitUrl?: string;
+
+	/** Persist the last self-fetch form values in sessionStorage (keyed by endpoint) and prefill the form on reload. */
+	@property({ type: Boolean })
+	remember = false;
+
+	/** True while an uncontrolled self-fetch is in flight. Public so {@link FetchController} can drive it. */
+	@state()
+	loading = false;
+
+	/** Message from a failed self-fetch, or null. Public so {@link FetchController} can drive it. */
+	@state()
+	error: string | null = null;
+
+	private fetcher: FetchController<T>;
+
+	constructor() {
+		super();
+		// Controlled mode: hydrate `data` from a direct-child roxy-data island when
+		// no JS property was assigned. Keyless; the server already fetched.
+		new MarkupDataController<T>(this);
+		this.fetcher = new FetchController<T>(this);
+	}
+
+	protected willUpdate(changed: PropertyValues): void {
+		if (changed.has('publishableKey')) {
+			this.fetcher.publishableKey = this.publishableKey;
+		}
+		if (changed.has('baseUrl') && this.baseUrl) {
+			this.fetcher.baseUrl = this.baseUrl;
+		}
+		if (changed.has('submitUrl')) {
+			this.fetcher.submitUrl = this.submitUrl;
+		}
+	}
+
+	render(): unknown {
+		if (this.loading) return this.renderLoading();
+		if (this.error != null) return this.renderError(this.error);
+		if (this.data != null) return this.renderData(this.data);
+		return this.renderNoData();
+	}
+
+	/** Render the populated response. The single method every component implements. */
+	protected abstract renderData(data: T): unknown;
+
+	/** The data-absent branch: the self-fetch form when an endpoint is set, otherwise the empty state. */
+	protected renderNoData(): unknown {
+		return this.endpoint ? this.renderForm() : this.renderEmpty();
+	}
+
+	/** Internal self-fetch form. Reuses the introspecting `<roxy-endpoint-form>`; the consumer never places it. */
+	protected renderForm(): unknown {
+		return html`<roxy-endpoint-form
+			data-endpoint=${this.endpoint}
+			method=${this.method}
+			spec-url=${ifDefined(this.specUrl)}
+			.initialValues=${this.remember ? this.readRemembered() : undefined}
+			@roxy-submit=${this.onFormSubmit}
+		></roxy-endpoint-form>`;
+	}
+
+	private onFormSubmit = (e: Event) => {
+		const detail = (e as CustomEvent).detail as {
+			values: Record<string, unknown>;
+		};
+		if (this.remember) this.writeRemembered(detail.values);
+		void this.fetcher.run(
+			buildRequest(this.endpoint, this.method, detail.values),
+		);
+	};
+
+	/** sessionStorage key for this component's remembered form values, scoped by endpoint. */
+	private rememberKey(): string {
+		return `roxy-ui:form:${this.endpoint}`;
+	}
+
+	private readRemembered(): Record<string, unknown> | undefined {
+		try {
+			const raw = sessionStorage.getItem(this.rememberKey());
+			return raw ? (JSON.parse(raw) as Record<string, unknown>) : undefined;
+		} catch {
+			return undefined;
+		}
+	}
+
+	private writeRemembered(values: Record<string, unknown>): void {
+		try {
+			sessionStorage.setItem(this.rememberKey(), JSON.stringify(values));
+		} catch {
+			// Private mode / disabled storage: remembering is best-effort, never fatal.
+		}
+	}
+
+	/** Terminal empty state. Subclasses override for a domain-specific message. */
+	protected renderEmpty(): unknown {
+		return html`<div class="roxy-empty" role="status">No data</div>`;
+	}
+
+	/** Loading placeholder shown during a self-fetch. */
+	protected renderLoading(): unknown {
+		return html`<div
+			class="roxy-skeleton"
+			style="height: 8rem"
+			role="status"
+			aria-label="Loading"
+		></div>`;
+	}
+
+	/** Error state shown when a self-fetch fails. Keeps the form in view so the request can be retried. */
+	protected renderError(message: string): unknown {
+		const banner = html`<div class="roxy-error" role="alert">${message}</div>`;
+		return this.endpoint ? html`${banner}${this.renderForm()}` : banner;
+	}
+}

package/src/utils/base-styles.ts

@@ -25,6 +25,18 @@ export const baseStyles = css`
 			var(--roxy-motion-easing, cubic-bezier(0.4, 0, 0.2, 1)) both;
 	}
 
+	/**
+	 * Opt out of the component's own card surface. When the embedder already
+	 * wraps the component in their own card, set the \`bare\` attribute to drop
+	 * the painted background + shadow so there is no nested card chrome. The
+	 * inner border stays a hairline; override --roxy-border to remove it too.
+	 */
+	:host([bare]) {
+		--roxy-surface: transparent;
+		--roxy-shadow-sm: none;
+		--roxy-shadow-md: none;
+	}
+
 	*,
 	*::before,
 	*::after {
@@ -82,6 +94,27 @@ export const baseStyles = css`
 		font-size: var(--roxy-text-sm, 0.875rem);
 	}
 
+	.roxy-error {
+		display: grid;
+		gap: var(--roxy-space-sm, 0.5rem);
+		justify-items: start;
+		padding: var(--roxy-space-lg, 1.5rem);
+		background: var(--roxy-surface, #fff);
+		border: 1px solid var(--roxy-danger, #dc2626);
+		border-radius: var(--roxy-radius-md, 8px);
+		color: var(--roxy-danger-fg, #991b1b);
+		font-size: var(--roxy-text-sm, 0.875rem);
+	}
+
+	/* Opt-in component backdrop. A component that paints content directly (table,
+	 * grid, prose) adds this to its root so it sits on an owned, theme-aware
+	 * surface rather than inheriting the page background, which may not match the
+	 * resolved token theme and would render text on a same-tone background. */
+	.roxy-surface {
+		background: var(--roxy-surface, #fff);
+		color: var(--roxy-fg, #0a0a0a);
+	}
+
 	:host(:focus-within) .roxy-card {
 		outline: 2px solid var(--roxy-ring, rgba(245, 158, 11, 0.4));
 		outline-offset: 2px;

package/src/utils/fetch-controller.ts

@@ -0,0 +1,166 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+
+/**
+ * Host slots the controller drives. {@link RoxyDataElement} satisfies this, so
+ * the form mixin can attach a controller without the component wiring state by hand.
+ */
+interface FetchHost<T> extends ReactiveControllerHost {
+	data: T | null;
+	loading: boolean;
+	error: string | null;
+}
+
+/** Default RoxyAPI v2 origin. A component overrides it per instance via its `base-url` attribute. */
+const DEFAULT_BASE_URL = 'https://roxyapi.com/api/v2';
+
+/** A single request the controller issues on the component's behalf. */
+export interface RoxyRequest {
+	/** Path under the API base, e.g. "/dreams/symbols/water" or "/astrology/natal-chart". */
+	path: string;
+	method?: 'GET' | 'POST';
+	/** JSON body for POST endpoints. */
+	body?: unknown;
+	/** Query string parameters; nullish values are dropped. */
+	query?: Record<string, string | number | undefined>;
+}
+
+/**
+ * Client-side fetch for uncontrolled (self-fetching) components: drives `host.data` / `host.loading` / `host.error` and cancels a stale request when a newer one starts or the host disconnects.
+ *
+ * @remarks
+ * Security boundary. The only credential this ever sends is a `pk_` publishable key, which carries a server-side origin allowlist. A secret (`sk_`) or legacy unprefixed key is refused before any network call and surfaced as an error, so a server secret cannot leak into a browser request. This centralizes the guard that originated in `<roxy-location-search>` so every self-fetching component enforces it identically.
+ *
+ * Controlled-mode components never construct this. When a server injects the response as a `<script class="roxy-data">` island, there is no key and no fetch, which is the path server-rendered consumers (WordPress, JSX SSR, static HTML) rely on.
+ */
+export class FetchController<T = unknown> implements ReactiveController {
+	private readonly host: FetchHost<T>;
+	private abort?: AbortController;
+
+	/** Browser-safe publishable key. Set by the host from its `publishable-key` attribute. */
+	publishableKey?: string;
+	/** API origin, overridable for self-hosted or proxied deployments. */
+	baseUrl = DEFAULT_BASE_URL;
+	/**
+	 * Consumer backend route that holds the secret key. When set, the request is POSTed here as `{ path, method, body, query }` instead of called against RoxyAPI directly, so no key (publishable or secret) is sent from the browser. This is the canonical path for server-rendered hosts (WordPress); the backend proxies the request with its own `sk_` key and returns the JSON response.
+	 */
+	submitUrl?: string;
+
+	constructor(host: FetchHost<T>) {
+		this.host = host;
+		host.addController(this);
+	}
+
+	hostDisconnected() {
+		this.abort?.abort();
+		this.abort = undefined;
+	}
+
+	/**
+	 * Issue the request and resolve once `host.data` (success) or `host.error`
+	 * (failure) is set. A no-op return when a non-publishable key is present:
+	 * the error is already surfaced and nothing is sent.
+	 */
+	async run(req: RoxyRequest): Promise<void> {
+		// submit-url proxy: no key leaves the browser; the consumer's backend holds it.
+		if (!this.submitUrl && this.secretKeyRefused()) return;
+		this.abort?.abort();
+		const controller = new AbortController();
+		this.abort = controller;
+		this.host.loading = true;
+		this.host.error = null;
+		try {
+			const res = this.submitUrl
+				? await fetch(this.submitUrl, {
+						method: 'POST',
+						headers: {
+							Accept: 'application/json',
+							'Content-Type': 'application/json',
+						},
+						body: JSON.stringify(req),
+						signal: controller.signal,
+					})
+				: await this.callApi(req, controller.signal);
+			if (!res.ok) throw new Error(await this.readError(res));
+			const json = (await res.json()) as T;
+			if (controller.signal.aborted) return;
+			this.host.data = json;
+		} catch (err) {
+			if ((err as { name?: string })?.name === 'AbortError') return;
+			this.host.error = err instanceof Error ? err.message : String(err);
+		} finally {
+			if (this.abort === controller) this.abort = undefined;
+			if (!controller.signal.aborted) this.host.loading = false;
+		}
+	}
+
+	/** Direct call against RoxyAPI with the publishable key (the no-backend path). */
+	private callApi(req: RoxyRequest, signal: AbortSignal): Promise<Response> {
+		const url = new URL(`${this.baseUrl}${req.path}`);
+		for (const [k, v] of Object.entries(req.query ?? {})) {
+			if (v != null) url.searchParams.set(k, String(v));
+		}
+		const headers: Record<string, string> = { Accept: 'application/json' };
+		if (this.publishableKey) headers['X-API-Key'] = this.publishableKey;
+		if (req.body != null) headers['Content-Type'] = 'application/json';
+		return fetch(url, {
+			method: req.method ?? 'GET',
+			headers,
+			body: req.body != null ? JSON.stringify(req.body) : undefined,
+			signal,
+		});
+	}
+
+	/** True when a key is set and it is not a browser-safe `pk_` publishable key. Surfaces the error and refuses to send. */
+	private secretKeyRefused(): boolean {
+		const key = this.publishableKey;
+		if (!key || key.startsWith('pk_')) return false;
+		this.host.error =
+			'Client-side components accept a pk_ publishable key only. Use a publishable key with an origin allowlist, or render server-side.';
+		(this.host as unknown as EventTarget).dispatchEvent(
+			new CustomEvent('roxy-validation-error', {
+				detail: { reason: 'possible-secret-key' },
+				bubbles: true,
+				composed: true,
+			}),
+		);
+		return true;
+	}
+
+	/** Surface the `{ error, code }` message the API returns on failure, falling back to the status code. */
+	private async readError(res: Response): Promise<string> {
+		try {
+			const body = (await res.json()) as { error?: string };
+			if (body?.error) return body.error;
+		} catch {
+			// Non-JSON error body: fall through to the status line.
+		}
+		return `Request failed (${res.status})`;
+	}
+}
+
+/**
+ * Translate flat form values into a {@link RoxyRequest} for an endpoint. The `{name}` segments in the endpoint template are substituted from the values and removed; the rest become the JSON body for POST or query parameters for GET. This is the spec-light request builder the base element uses to turn a `<roxy-endpoint-form>` submission into a self-fetch, so a component needs no per-endpoint glue.
+ */
+export function buildRequest(
+	endpoint: string,
+	method: 'GET' | 'POST',
+	values: Record<string, unknown>,
+): RoxyRequest {
+	const rest: Record<string, unknown> = { ...values };
+	const path = `/${endpoint.replace(/^\//, '')}`.replace(
+		/\{([^}]+)\}/g,
+		(_match, name: string) => {
+			const v = rest[name];
+			delete rest[name];
+			return encodeURIComponent(String(v ?? ''));
+		},
+	);
+	const query: Record<string, string | number | undefined> = {};
+	const body: Record<string, unknown> = {};
+	for (const [k, v] of Object.entries(rest)) {
+		if (v === undefined || v === '') continue;
+		if (method === 'GET') query[k] = v as string | number;
+		else body[k] = v;
+	}
+	return { path, method, query, body: method === 'POST' ? body : undefined };
+}

package/src/utils/kundli-render.ts

@@ -173,6 +173,7 @@ function renderPlanetStack(
  *
  * @param meta - Graha-keyed map; missing rashi entries are skipped.
  * @param divisionLabel - Optional title written inside the chart centre.
+ * @param lagnaOverride - Optional rashi/sign name (case-insensitive, e.g. `"cancer"`) that replaces the `meta.Lagna`-derived ascendant. Drives the Chandra Lagna (Moon-as-ascendant) and other reference-point views: the `meta` of a `/birth-chart` response always carries the Janma Lagna as its `Lagna` key, so this is the only way to pivot the houses without a second request. Ignored when it does not resolve to a known sign.
  */
 export function toKundliViewModel(
 	meta: Record<
@@ -187,14 +188,20 @@ export function toKundliViewModel(
 		}
 	>,
 	divisionLabel?: string,
+	lagnaOverride?: string,
 ): KundliViewModel {
 	const placements: Record<string, PlacedGraha[]> = {};
 	for (const sign of SIGNS_ORDER) placements[sign.toLowerCase()] = [];
-	let lagnaSign = '';
+	const override = lagnaOverride
+		? (RASHI_TO_SIGN[lagnaOverride.toLowerCase()] ?? '')
+		: '';
+	let lagnaSign = override;
 	for (const [name, pos] of Object.entries(meta ?? {})) {
 		const rashiKey = (pos?.rashi ?? '').toLowerCase();
 		if (name === 'Lagna' || pos?.graha === 'Lagna') {
-			lagnaSign = RASHI_TO_SIGN[rashiKey] ?? '';
+			// An explicit override pins the ascendant; otherwise the Janma Lagna
+			// from meta is the reference point.
+			if (!override) lagnaSign = RASHI_TO_SIGN[rashiKey] ?? '';
 			continue;
 		}
 		if (!rashiKey || !(rashiKey in placements)) continue;

package/src/utils/kundli-styles.ts

@@ -13,6 +13,12 @@ import { css } from 'lit';
  */
 export const kundliStyles = css`
 	.wrap {
+		background: var(--roxy-surface, #fff);
+		color: var(--roxy-fg, #0a0a0a);
+		border: 1px solid var(--roxy-border, #e4e4e7);
+		border-radius: var(--roxy-radius-md, 8px);
+		padding: var(--roxy-space-lg, 1.5rem);
+		box-shadow: var(--roxy-shadow-sm);
 		display: grid;
 		gap: var(--roxy-space-md, 1rem);
 	}
@@ -31,7 +37,7 @@ export const kundliStyles = css`
 	svg {
 		display: block;
 		width: 100%;
-		max-width: 560px;
+		max-width: var(--roxy-chart-max-width, 560px);
 		aspect-ratio: 1 / 1;
 		height: auto;
 		margin: 0 auto;

package/src/utils/markup-data.ts

@@ -12,6 +12,51 @@ import type { ReactiveController, ReactiveControllerHost } from 'lit';
  */
 const ROXY_DATA_CLASS = 'roxy-data';
 
+/**
+ * Serialize a RoxyAPI response for embedding inside an inline `<script type="application/json" class="roxy-data">`. This is the safe writer counterpart to {@link MarkupDataController}, the reader: server-rendered and cached consumers (WordPress, JSX SSR, static HTML) emit the script with this, and the component hydrates `data` from it on connect.
+ *
+ * @remarks
+ * Use this instead of a bare `JSON.stringify`. A raw stringify of a response that contains the literal text `</script>` (common in long interpretation prose) closes the script element early, corrupting the page and creating an HTML-injection vector. This escapes the script-unsafe characters to their `\uXXXX` JSON escapes, which `JSON.parse` restores to the original characters, so the value the component receives is identical to the response you passed.
+ *
+ * `<` is the load-bearing escape (it defeats `</script>` and `<!--`). `>` and `&` are escaped for defence in depth, and U+2028 / U+2029 because they are valid in JSON yet are line terminators in a `<script>` context and break some parsers. The escapes introduce only `\uXXXX` sequences, so the replacements never feed each other and order is irrelevant.
+ *
+ * Pass the unwrapped RoxyAPI response, the same shape you would assign to `element.data`. Do not pass the SDK envelope (`{ data, error, request, response }`).
+ *
+ * @example
+ * ```ts
+ * import { serializeRoxyData } from '@roxyapi/ui';
+ *
+ * const { data } = await roxy.dreams.getDreamSymbol({ path: { id: 'water' } });
+ * const html = `<roxy-dream-card><script type="application/json" class="roxy-data">${serializeRoxyData(data)}</script></roxy-dream-card>`;
+ * ```
+ */
+export function serializeRoxyData(data: unknown): string {
+	return JSON.stringify(data)
+		.replace(/</g, '\\u003c')
+		.replace(/>/g, '\\u003e')
+		.replace(/&/g, '\\u0026')
+		.replace(/\u2028/g, '\\u2028')
+		.replace(/\u2029/g, '\\u2029');
+}
+
+/**
+ * Build the complete `<script type="application/json" class="roxy-data">…</script>` element a server nests inside a `roxy-*` component for the no-JavaScript hydration path. The payload is escaped via {@link serializeRoxyData}, so it is safe to drop straight into HTML output.
+ *
+ * @remarks
+ * The element carries both `type="application/json"` and `class="roxy-data"` because {@link MarkupDataController} reads only a direct-child script that has both. Emit one of these inside the target component; the JavaScript `data` property still wins if it is later assigned.
+ *
+ * @example
+ * ```ts
+ * import { roxyDataScript } from '@roxyapi/ui';
+ *
+ * const { data } = await roxy.crystals.getCrystal({ path: { id: 'amethyst' } });
+ * const html = `<roxy-crystal-grid>${roxyDataScript(data)}</roxy-crystal-grid>`;
+ * ```
+ */
+export function roxyDataScript(data: unknown): string {
+	return `<script type="application/json" class="${ROXY_DATA_CLASS}">${serializeRoxyData(data)}</script>`;
+}
+
 /**
  * True when the element is a `<script type="application/json">`. Uses tag name and attribute rather than `instanceof HTMLScriptElement` so the check holds in every DOM implementation, including server-rendered and hydration runtimes where the constructor global may be absent.
  */

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by scripts/sync-version.ts. Do not edit.
-export const ROXY_UI_VERSION = '0.9.0';
+export const ROXY_UI_VERSION = '0.11.0';