@gjsify/adwaita-core 0.14.0

package/lib/esm/_virtual/_rolldown/runtime.js

@@ -0,0 +1 @@
+var e=Object.defineProperty,__name=(t,n)=>e(t,`name`,{value:n,configurable:!0});export{__name};

package/lib/esm/breakpoint.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";const e=/^(min|max)-(width|height)\s*:\s*(\d+(?:\.\d+)?)\s*(px|sp|pt)?$/i;function isLeaf(e){return e.op===void 0}function splitOn(e,t){let n=0;for(let r=e.length-1;r>=0;r--){let i=e[r];if(i===`)`)n++;else if(i===`(`)n--;else if(n===0){let n=r-t.length+1;if(n>0&&r+1<e.length&&/\s/.test(e[n-1])&&/\s/.test(e[r+1])&&e.slice(n,r+1).toLowerCase()===t)return{left:e.slice(0,n),right:e.slice(r+1)}}}return null}function splitTopLevel(e){for(let t of[`or`,`and`]){let n=splitOn(e,t);if(n)return{op:t,...n}}return null}function parseBreakpointCondition(t){let n=t.trim();if(!n)return null;let r=splitTopLevel(n);if(r){let e=parseBreakpointCondition(r.left),t=parseBreakpointCondition(r.right);return!e||!t?null:{op:r.op,left:e,right:t}}if(n.startsWith(`(`)&&n.endsWith(`)`))return parseBreakpointCondition(n.slice(1,-1));let i=e.exec(n);return i?{bound:i[1].toLowerCase(),dimension:i[2].toLowerCase(),value:Number.parseFloat(i[3])}:null}function evaluateBreakpointCondition(e,t){if(isLeaf(e)){let n=e.dimension===`width`?t.width:t.height;return e.bound===`max`?n<=e.value:n>=e.value}let n=evaluateBreakpointCondition(e.left,t);return e.op===`and`?n&&evaluateBreakpointCondition(e.right,t):n||evaluateBreakpointCondition(e.right,t)}var AdwBreakpoint=class{constructor(e,t){this._applied=!1,this.condition=typeof e==`string`?parseBreakpointCondition(e):e??null,this._handlers=t}get applied(){return this._applied}evaluate(e){let t=this.condition?evaluateBreakpointCondition(this.condition,e):!1;return t===this._applied?this._applied:(this._applied=t,t?this._handlers.onApply():this._handlers.onUnapply?.(),this._applied)}};export{AdwBreakpoint,evaluateBreakpointCondition,parseBreakpointCondition};

package/lib/esm/color-scheme.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";const e=`#33333A`,t=`#FFFFFF`;let n=`light`;const r=new Set;function adwaitaColorScheme(){return n}function setAdwaitaColorScheme(e){let t=e===`dark`?`dark`:`light`;if(t!==n){n=t;for(let e of[...r])try{e()}catch{}}}function toggleAdwaitaColorScheme(){return setAdwaitaColorScheme(n===`dark`?`light`:`dark`),n}function themeIconColor(){return n===`dark`?t:e}function isThemeIconColor(e){return e===`#33333A`||e===`#FFFFFF`}function onAdwaitaColorSchemeChanged(e){return r.add(e),()=>{r.delete(e)}}export{e as DEFAULT_ICON_COLOR,t as DEFAULT_ICON_COLOR_DARK,adwaitaColorScheme,isThemeIconColor,onAdwaitaColorSchemeChanged,setAdwaitaColorScheme,themeIconColor,toggleAdwaitaColorScheme};

package/lib/esm/dialog.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";var AdwAlertResponses=class{constructor(e=``,t=``){this._responses=[],this._defaultResponse=null,this._closeResponse=`close`,this._heading=e??``,this._body=t??``}get heading(){return this._heading}set heading(e){this._heading=e??``}get body(){return this._body}set body(e){this._body=e??``}addResponse(e,t,n={}){let r=this._responses.find(t=>t.id===e);if(r){r.label=t,n.appearance!==void 0&&(r.appearance=n.appearance),n.enabled!==void 0&&(r.enabled=n.enabled);return}this._responses.push({id:e,label:t,appearance:n.appearance??`default`,enabled:n.enabled??!0})}addResponses(...e){for(let t=0;t+1<e.length;t+=2)this.addResponse(e[t],e[t+1])}hasResponse(e){return this._responses.some(t=>t.id===e)}setResponseAppearance(e,t){let n=this._responses.find(t=>t.id===e);n&&(n.appearance=t)}getResponseAppearance(e){return this._responses.find(t=>t.id===e)?.appearance??`default`}setResponseEnabled(e,t){let n=this._responses.find(t=>t.id===e);n&&(n.enabled=t)}getResponseEnabled(e){return this._responses.find(t=>t.id===e)?.enabled??!0}get responses(){return this._responses}get defaultResponse(){return this._defaultResponse}set defaultResponse(e){this._defaultResponse=e}get closeResponse(){return this._closeResponse}set closeResponse(e){this._closeResponse=e||`close`}get usesActionSheet(){return this._responses.length>3}orderResponses(){let e=this._responses.find(e=>e.id===this._defaultResponse)??this._responses[0],t=this._responses.filter(t=>t!==e);return{ok:e,cancel:t[t.length-1],neutral:t.length>=2?t[0]:void 0}}resolveById(e){return e!=null&&this.hasResponse(e)?e:this._closeResponse}resolveLabel(e){return e==null?this._closeResponse:this.resolveById(this._responses.find(t=>t.label===e)?.id)}};export{AdwAlertResponses};

package/lib/esm/index.js

@@ -0,0 +1 @@
+import{AdwBreakpoint as e,evaluateBreakpointCondition as t,parseBreakpointCondition as n}from"./breakpoint.js";import{DEFAULT_ICON_COLOR as r,DEFAULT_ICON_COLOR_DARK as i,adwaitaColorScheme as a,isThemeIconColor as o,onAdwaitaColorSchemeChanged as s,setAdwaitaColorScheme as c,themeIconColor as l,toggleAdwaitaColorScheme as u}from"./color-scheme.js";import{AdwAlertResponses as d}from"./dialog.js";import{AdwToast as f,AdwToastQueue as p,DEFAULT_TOAST_TIMEOUT as m}from"./toast.js";export{d as AdwAlertResponses,e as AdwBreakpoint,f as AdwToast,p as AdwToastQueue,r as DEFAULT_ICON_COLOR,i as DEFAULT_ICON_COLOR_DARK,m as DEFAULT_TOAST_TIMEOUT,a as adwaitaColorScheme,t as evaluateBreakpointCondition,o as isThemeIconColor,s as onAdwaitaColorSchemeChanged,n as parseBreakpointCondition,c as setAdwaitaColorScheme,l as themeIconColor,u as toggleAdwaitaColorScheme};

package/lib/esm/toast.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";const e=5e3;var AdwToast=class{constructor(e=``,t={}){this.title=e,this.timeout=t.timeout??5e3,this.buttonLabel=t.buttonLabel??``}get hasButton(){return this.buttonLabel.length>0}},AdwToastQueue=class{constructor(e){this._pending=[],this._current=null,this._timer=null,this._scheduler=e.scheduler,this._handlers={onShow:e.onShow,onHide:e.onHide}}get current(){return this._current}get showing(){return this._current!==null}get pending(){return this._pending.length}add(e){this._current===null?this._show(e):this._pending.push(e)}dismiss(){if(this._current===null)return;let e=this._current;this._clearTimer(),this._current=null,this._handlers.onHide(e);let t=this._pending.shift();t&&this._show(t)}clear(){if(this._pending.length=0,this._current===null)return;let e=this._current;this._clearTimer(),this._current=null,this._handlers.onHide(e)}_show(e){this._current=e,this._handlers.onShow(e),e.timeout>0&&(this._timer=this._scheduler.schedule(()=>{this._current===e&&this.dismiss()},e.timeout))}_clearTimer(){this._timer!==null&&(this._scheduler.cancel(this._timer),this._timer=null)}};export{AdwToast,AdwToastQueue,e as DEFAULT_TOAST_TIMEOUT};

package/lib/types/breakpoint.d.ts

@@ -0,0 +1,61 @@
+/** The two size axes a condition can test. */
+export type BreakpointDimension = 'width' | 'height';
+/** Whether a leaf is a lower (`min`) or upper (`max`) bound. */
+export type BreakpointBound = 'min' | 'max';
+/** A single `min-/max-width/height: <value>` comparison (value in DIPs). */
+export interface BreakpointConditionLeaf {
+    dimension: BreakpointDimension;
+    bound: BreakpointBound;
+    /** Threshold in DIPs (the parsed `px` / `sp` / `pt` value). */
+    value: number;
+}
+/** A boolean combination of two condition nodes. */
+export interface BreakpointConditionGroup {
+    op: 'and' | 'or';
+    left: BreakpointConditionNode;
+    right: BreakpointConditionNode;
+}
+/** A parsed breakpoint condition: a leaf comparison or an and/or group. */
+export type BreakpointConditionNode = BreakpointConditionLeaf | BreakpointConditionGroup;
+/** A measured size in DIPs. */
+export interface BreakpointSize {
+    width: number;
+    height: number;
+}
+/**
+ * Parse a Libadwaita breakpoint condition string into a {@link BreakpointConditionNode}.
+ * Accepts a single comparison (`'max-width: 720sp'`), and/or chains
+ * (`'max-width: 720sp and max-height: 480sp'`), and parenthesised groups. Units
+ * are read as DIPs. Returns null when the string can't be parsed.
+ */
+export declare function parseBreakpointCondition(spec: string): BreakpointConditionNode | null;
+/** Evaluate a parsed condition against a measured size (DIPs). */
+export declare function evaluateBreakpointCondition(node: BreakpointConditionNode, size: BreakpointSize): boolean;
+/** Callbacks run as a breakpoint's condition flips. */
+export interface AdwBreakpointHandlers {
+    /** Run when the condition becomes true (the narrow/large state is entered). */
+    onApply: () => void;
+    /** Run when the condition becomes false again. Optional. */
+    onUnapply?: () => void;
+}
+/**
+ * A single responsive breakpoint: a condition plus apply/unapply callbacks.
+ * Mirrors `Adw.Breakpoint`. Drive {@link evaluate} from your renderer's size
+ * source (e.g. `addBreakpoints` in `@gjsify/adwaita-nativescript`, or a
+ * `ResizeObserver` in a browser renderer).
+ */
+export declare class AdwBreakpoint {
+    /** The parsed condition (null when an invalid string was passed). */
+    readonly condition: BreakpointConditionNode | null;
+    private _handlers;
+    private _applied;
+    constructor(condition: string | BreakpointConditionNode | null, handlers: AdwBreakpointHandlers);
+    /** Whether the condition is currently satisfied (apply has fired, not unapply). */
+    get applied(): boolean;
+    /**
+     * Re-evaluate against `size`, firing apply / unapply ONLY on a state change
+     * (so a steady stream of layout passes doesn't re-run the callbacks). Returns
+     * the post-evaluation applied state. A null condition never applies.
+     */
+    evaluate(size: BreakpointSize): boolean;
+}

package/lib/types/breakpoint.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/color-scheme.d.ts

@@ -0,0 +1,27 @@
+/** Default symbolic-icon fill for light theme — Adwaita's ~`rgba(0,0,0,0.8)` fg. */
+export declare const DEFAULT_ICON_COLOR = "#33333A";
+/** Default symbolic-icon fill for dark theme — near-white fg. */
+export declare const DEFAULT_ICON_COLOR_DARK = "#FFFFFF";
+/** The two Adwaita color schemes. */
+export type AdwColorScheme = 'light' | 'dark';
+/** The active color scheme (default `'light'`). */
+export declare function adwaitaColorScheme(): AdwColorScheme;
+/**
+ * Set the active color scheme. A no-op when unchanged; otherwise notifies every
+ * subscriber (so theme-aware icons re-render). The renderer should also apply
+ * its platform half (e.g. the `ns-dark` class on NativeScript, a CSS scope in
+ * the browser).
+ */
+export declare function setAdwaitaColorScheme(scheme: AdwColorScheme): void;
+/** Flip light↔dark and return the new scheme. */
+export declare function toggleAdwaitaColorScheme(): AdwColorScheme;
+/** The default symbolic-icon fill for the active scheme (dark fg on light, near-white on dark). */
+export declare function themeIconColor(): string;
+/** Whether `color` is the current scheme-default fill (i.e. not a caller-set explicit colour). */
+export declare function isThemeIconColor(color: string): boolean;
+/**
+ * Subscribe to scheme changes. Returns an unsubscribe function. Widgets should
+ * subscribe while on screen and unsubscribe when leaving it (e.g. NS `loaded` /
+ * `unloaded`), so the registry only ever holds live subscribers.
+ */
+export declare function onAdwaitaColorSchemeChanged(listener: () => void): () => void;

package/lib/types/color-scheme.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/dialog.d.ts

@@ -0,0 +1,100 @@
+/** Visual emphasis of a response button. Mirrors `Adw.ResponseAppearance`. */
+export type AdwResponseAppearance = 'default' | 'suggested' | 'destructive';
+/** Optional per-response attributes for {@link AdwAlertResponses.addResponse}. */
+export interface AdwResponseOptions {
+    /** Emphasis (suggested/destructive). Default `'default'`. Mirrors `set_response_appearance`. */
+    appearance?: AdwResponseAppearance;
+    /** Whether the response is selectable. Default `true`. Mirrors `set_response_enabled`. */
+    enabled?: boolean;
+}
+/** A registered response button. `id` is what `present()` resolves to. */
+export interface AdwAlertResponse {
+    /** Stable response id — the value `present()` resolves to. */
+    readonly id: string;
+    /** Button label shown to the user. */
+    label: string;
+    /** Visual emphasis. */
+    appearance: AdwResponseAppearance;
+    /** Whether the response is selectable. */
+    enabled: boolean;
+}
+/**
+ * The response list split into the three slots a native two/three-button dialog
+ * exposes: the emphasised OK (the default response, or the first), the trailing
+ * cancel/close, and an optional middle neutral. Any slot may be absent.
+ */
+export interface OrderedConfirmResponses {
+    ok?: AdwAlertResponse;
+    cancel?: AdwAlertResponse;
+    neutral?: AdwAlertResponse;
+}
+/**
+ * The headless alert-dialog response model. Holds the heading/body text and the
+ * response registry; owns the ordering + validation a renderer's `present()`
+ * needs. Renderer-agnostic: compose it inside a platform dialog (e.g. NativeScript
+ * `AdwAlertDialog extends Observable`) and delegate the response surface to it.
+ */
+export declare class AdwAlertResponses {
+    private _heading;
+    private _body;
+    private readonly _responses;
+    private _defaultResponse;
+    private _closeResponse;
+    constructor(heading?: string, body?: string);
+    /** The dialog heading (title). */
+    get heading(): string;
+    set heading(value: string);
+    /** The dialog body text. */
+    get body(): string;
+    set body(value: string);
+    /**
+     * Register a response button. `id` is what `present()` resolves to; a repeated
+     * `id` updates the existing response's label/appearance/enabled in place
+     * (mirroring `adw_alert_dialog_add_response` refusing duplicate ids).
+     */
+    addResponse(id: string, label: string, options?: AdwResponseOptions): void;
+    /** Register many responses at once (`id, label, id, label, …`). */
+    addResponses(...idLabelPairs: string[]): void;
+    /** Whether a response with `id` is registered. */
+    hasResponse(id: string): boolean;
+    /** Set a registered response's visual emphasis. No-op for an unknown id. */
+    setResponseAppearance(id: string, appearance: AdwResponseAppearance): void;
+    /** A registered response's emphasis, or `'default'` for an unknown id. */
+    getResponseAppearance(id: string): AdwResponseAppearance;
+    /** Enable/disable a registered response. No-op for an unknown id. */
+    setResponseEnabled(id: string, enabled: boolean): void;
+    /** Whether a registered response is enabled (`true` for an unknown id). */
+    getResponseEnabled(id: string): boolean;
+    /** The registered responses, in insertion order. */
+    get responses(): ReadonlyArray<AdwAlertResponse>;
+    /** The default (emphasised) response id — the OK slot in a native dialog. */
+    get defaultResponse(): string | null;
+    set defaultResponse(id: string | null);
+    /** The response id used when the dialog is dismissed without a choice. */
+    get closeResponse(): string;
+    set closeResponse(id: string);
+    /**
+     * Whether the response list is too long for a plain two/three-button alert
+     * (so a renderer falls back to an action sheet). Mirrors the NativeScript
+     * `confirm()` (≤3) vs `action()` (>3) split.
+     */
+    get usesActionSheet(): boolean;
+    /**
+     * Split the responses into the native OK / cancel / neutral slots: the default
+     * response (or the first) is OK, the LAST remaining is cancel/close, and a
+     * middle one (when present) is neutral — the ordering a native two/three-button
+     * dialog expects.
+     */
+    orderResponses(): OrderedConfirmResponses;
+    /**
+     * Resolve a chosen response id to a REGISTERED id — the resolve-to-chosen-id
+     * contract. Returns `id` when it names a registered response, otherwise
+     * {@link closeResponse} (covering `null` / dismissal / an unknown id).
+     */
+    resolveById(id: string | null | undefined): string;
+    /**
+     * Resolve a chosen LABEL (e.g. an action-sheet selection) to a registered id,
+     * or {@link closeResponse} when the label matches nothing / was dismissed.
+     */
+    resolveLabel(label: string | null | undefined): string;
+}

package/lib/types/dialog.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+export { AdwBreakpoint, evaluateBreakpointCondition, parseBreakpointCondition, } from './breakpoint.js';
+export type { AdwBreakpointHandlers, BreakpointBound, BreakpointConditionGroup, BreakpointConditionLeaf, BreakpointConditionNode, BreakpointDimension, BreakpointSize, } from './breakpoint.js';
+export { DEFAULT_ICON_COLOR, DEFAULT_ICON_COLOR_DARK, adwaitaColorScheme, isThemeIconColor, onAdwaitaColorSchemeChanged, setAdwaitaColorScheme, themeIconColor, toggleAdwaitaColorScheme, } from './color-scheme.js';
+export type { AdwColorScheme } from './color-scheme.js';
+export { AdwToast, AdwToastQueue, DEFAULT_TOAST_TIMEOUT } from './toast.js';
+export type { AdwToastOptions, AdwToastQueueHandlers, AdwToastQueueOptions, ToastScheduler, ToastTimerHandle, } from './toast.js';
+export { AdwAlertResponses } from './dialog.js';
+export type { AdwAlertResponse, AdwResponseAppearance, AdwResponseOptions, OrderedConfirmResponses, } from './dialog.js';

package/lib/types/toast.d.ts

@@ -0,0 +1,89 @@
+/** Default toast lifetime, in milliseconds (Adwaita's default ≈ 5 s). */
+export declare const DEFAULT_TOAST_TIMEOUT = 5000;
+/** Options for constructing an {@link AdwToast}. Mirrors `Adw.Toast`'s properties. */
+export interface AdwToastOptions {
+    /** Auto-dismiss timeout in ms (`0` = sticky until dismissed). Default {@link DEFAULT_TOAST_TIMEOUT}. */
+    timeout?: number;
+    /** Optional action-button label (empty = no button). Mirrors `Adw.Toast:button-label`. */
+    buttonLabel?: string;
+}
+/**
+ * A single transient toast descriptor. Mirrors `Adw.Toast` — a value object
+ * (title + auto-dismiss timeout + optional action) enqueued via
+ * {@link AdwToastQueue.add}.
+ */
+export declare class AdwToast {
+    /** The toast message. */
+    title: string;
+    /** Auto-dismiss timeout in ms (`0` = sticky). */
+    timeout: number;
+    /** Action-button label (empty = no button). */
+    buttonLabel: string;
+    constructor(title?: string, options?: AdwToastOptions);
+    /** Whether this toast carries an action button (the action-button render state). */
+    get hasButton(): boolean;
+}
+/** Opaque handle a {@link ToastScheduler} returns for a scheduled auto-dismiss. */
+export type ToastTimerHandle = unknown;
+/**
+ * The injected timing seam. A renderer wraps its platform timer (NativeScript's
+ * `setTimeout`/`clearTimeout`, the browser's, a deterministic fake in tests). The
+ * queue never references a global `setTimeout`, keeping core platform-neutral.
+ */
+export interface ToastScheduler {
+    /** Run `callback` after `ms`; return a handle {@link cancel} understands. */
+    schedule(callback: () => void, ms: number): ToastTimerHandle;
+    /** Cancel a pending {@link schedule}. A stale/unknown handle must be a no-op. */
+    cancel(handle: ToastTimerHandle): void;
+}
+/** Render seams driven by the queue as toasts enter/leave the single visible slot. */
+export interface AdwToastQueueHandlers {
+    /** Mount `toast` as the visible strip (title + optional action button). */
+    onShow: (toast: AdwToast) => void;
+    /** Tear down `toast`'s strip — it auto-dismissed, was dismissed, or superseded. */
+    onHide: (toast: AdwToast) => void;
+}
+/** Construction seams for {@link AdwToastQueue}: the timing + render adapters. */
+export interface AdwToastQueueOptions extends AdwToastQueueHandlers {
+    scheduler: ToastScheduler;
+}
+/**
+ * The headless toast queue — `Adw.ToastOverlay`'s one-at-a-time policy + ordering
+ * + auto-dismiss lifecycle, with zero rendering and zero global timers.
+ *
+ * {@link add} enqueues a toast; the first shows immediately (`onShow`), later ones
+ * wait FIFO. A shown toast with `timeout > 0` auto-dismisses through the injected
+ * {@link ToastScheduler}; {@link dismiss} dismisses the current toast early. Either
+ * way, dismissal fires `onHide` and advances to the next queued toast.
+ */
+export declare class AdwToastQueue {
+    private readonly _scheduler;
+    private readonly _handlers;
+    private readonly _pending;
+    private _current;
+    private _timer;
+    constructor(options: AdwToastQueueOptions);
+    /** The toast currently on screen, or `null` when nothing is shown. */
+    get current(): AdwToast | null;
+    /** Whether a toast is currently on screen. */
+    get showing(): boolean;
+    /** Number of toasts waiting behind the current one. */
+    get pending(): number;
+    /**
+     * Enqueue a toast. Shows it immediately when the slot is free, otherwise
+     * queues it FIFO behind the toasts already waiting.
+     */
+    add(toast: AdwToast): void;
+    /**
+     * Dismiss the current toast early (fires `onHide` and advances to the next
+     * queued toast, if any). A no-op when nothing is shown.
+     */
+    dismiss(): void;
+    /**
+     * Drop every toast — dismiss the current one (firing `onHide`) and discard the
+     * pending queue WITHOUT showing them (unlike {@link dismiss}, which advances).
+     */
+    clear(): void;
+    private _show;
+    private _clearTimer;
+}

package/lib/types/toast.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@gjsify/adwaita-core",
+    "version": "0.14.0",
+    "description": "Headless Adwaita widget behavior (breakpoint condition grammar + apply/unapply state machine, color-scheme observable) shared by the web and NativeScript Adwaita renderers — pure TS, no platform imports",
+    "type": "module",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        }
+    },
+    "files": [
+        "lib"
+    ],
+    "scripts": {
+        "clear": "rm -rf lib tmp dist tsconfig.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+        "build:types": "gjsify tsc",
+        "build:test": "gjsify run build:test:gjs && gjsify run build:test:node && gjsify run build:test:browser",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+        "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+        "build:test:browser": "gjsify build src/test.browser.mts --app browser --outfile dist/test.browser.mjs",
+        "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:node && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.mjs",
+        "test:node": "node test.node.mjs"
+    },
+    "keywords": [
+        "gjs",
+        "node",
+        "browser",
+        "nativescript",
+        "adwaita",
+        "gnome",
+        "design-system",
+        "headless"
+    ],
+    "devDependencies": {
+        "@gjsify/cli": "^0.14.0",
+        "@gjsify/unit": "^0.14.0",
+        "@types/node": "^25.9.2",
+        "typescript": "^6.0.3"
+    },
+    "gjsify": {
+        "runtimes": {
+            "gjs": "polyfill",
+            "node": "polyfill",
+            "browser": "polyfill",
+            "nativescript": "polyfill"
+        },
+        "tier": 2
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/web/adwaita-core"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/web/adwaita-core#readme"
+}