vastlint-react 0.4.20

package/README.md

@@ -0,0 +1,14 @@
+# vastlint-react
+
+Headless React bindings for `vastlint-client`.
+
+Current status:
+
+- `useVastSession` is implemented as a thin hook over `vastlint-client` session instances.
+- The hook subscribes to session snapshots, supports auto-load and auto-validate, and exposes tracking-aware session state.
+- `useVastAnnotations` is implemented as a derived annotation model over `ValidationResult`, grouped by line and issue ID.
+- `useVastPlayback` is implemented as a thin hook over `createVastPlaybackController()`, with subscribed playback snapshots, optional auto-initialize behavior, and bound playback lifecycle methods.
+- `useVastPlaybackQueue` is implemented as a thin hook over `createVastPlaybackQueueController()`, with subscribed queue snapshots, optional auto-initialize behavior, and bound queue lifecycle methods.
+- Build-first Node smoke tests now cover `useVastSession`, `useVastAnnotations`, `useVastTracker`, `useVastPlayback`, and `useVastPlaybackQueue` against built package output via a `jsdom` plus `react-dom/client` harness.
+- `useVastTracker` is implemented as a thin hook over session tracking state and dispatch methods, including pod-aware `trackAd()` plus companion helpers for `getAdCompanions()`, `getCompanionTargets()`, and `trackCompanion()`.
+- The package will stay renderer-agnostic and return data models rather than opinionated UI.

package/dist/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { UseVastAnnotationsOptions, UseVastPlaybackOptions, UseVastPlaybackQueueOptions, UseVastSessionOptions, UseVastTrackerOptions, VastAnnotationModel, VastPlaybackHookResult, VastPlaybackQueueHookResult, VastSessionHookResult, VastTrackerHookResult } from "./types.js";
+export declare function useVastSession(options: UseVastSessionOptions): VastSessionHookResult;
+export declare function useVastAnnotations(_options: UseVastAnnotationsOptions): VastAnnotationModel;
+export declare function useVastPlayback(options: UseVastPlaybackOptions): VastPlaybackHookResult;
+export declare function useVastPlaybackQueue(options: UseVastPlaybackQueueOptions): VastPlaybackQueueHookResult;
+export declare function useVastTracker(options: UseVastTrackerOptions): VastTrackerHookResult;

package/dist/hooks.js

@@ -0,0 +1,431 @@
+import { startTransition, useDeferredValue, useEffect, useMemo, useReducer, useRef } from "react";
+import { createVastPlaybackController, createVastPlaybackQueueController, createVastSession, selectTrackingTargets } from "vastlint-client";
+function useSubscribedSnapshot(store) {
+    const [, forceRender] = useReducer((value) => value + 1, 0);
+    const storeRef = useRef(store);
+    const snapshotRef = useRef(store.getSnapshot());
+    if (!Object.is(storeRef.current, store)) {
+        storeRef.current = store;
+        snapshotRef.current = store.getSnapshot();
+    }
+    useEffect(() => {
+        snapshotRef.current = store.getSnapshot();
+        let isSynchronousSubscription = true;
+        const unsubscribe = store.subscribe((nextSnapshot) => {
+            if (isSynchronousSubscription) {
+                return;
+            }
+            snapshotRef.current = nextSnapshot;
+            forceRender();
+        });
+        isSynchronousSubscription = false;
+        return unsubscribe;
+    }, [store]);
+    return snapshotRef.current;
+}
+function createEmptyAnnotationModel() {
+    return {
+        annotations: [],
+        byLine: new Map(),
+        byIssueId: new Map(),
+    };
+}
+function countXmlLines(xml) {
+    if (!xml) {
+        return 0;
+    }
+    return xml.split(/\r\n?|\n/).length;
+}
+function buildVastAnnotationModel(xml, validation) {
+    if (!validation || validation.issues.length === 0) {
+        return createEmptyAnnotationModel();
+    }
+    const maxLine = countXmlLines(xml);
+    const annotations = validation.issues.map((issue, index) => {
+        const line = issue.line !== null && issue.line >= 1 && issue.line <= maxLine ? issue.line : null;
+        const col = line === null ? null : issue.col;
+        return {
+            id: `${issue.id}:${issue.path ?? "document"}:${line ?? 0}:${col ?? 0}:${index}`,
+            issueId: issue.id,
+            severity: issue.severity,
+            message: issue.message,
+            path: issue.path,
+            line,
+            col,
+        };
+    });
+    const byLine = new Map();
+    const byIssueId = new Map();
+    for (const annotation of annotations) {
+        if (annotation.line !== null) {
+            const lineAnnotations = byLine.get(annotation.line) ?? [];
+            lineAnnotations.push(annotation);
+            byLine.set(annotation.line, lineAnnotations);
+        }
+        const issueAnnotations = byIssueId.get(annotation.issueId) ?? [];
+        issueAnnotations.push(annotation);
+        byIssueId.set(annotation.issueId, issueAnnotations);
+    }
+    return {
+        annotations,
+        byLine,
+        byIssueId,
+    };
+}
+function serializeValidateOptions(validateOptions) {
+    if (!validateOptions) {
+        return "";
+    }
+    const sortedRuleOverrides = validateOptions.rule_overrides
+        ? Object.fromEntries(Object.entries(validateOptions.rule_overrides).sort(([left], [right]) => left.localeCompare(right)))
+        : undefined;
+    return JSON.stringify({
+        wrapper_depth: validateOptions.wrapper_depth ?? null,
+        max_wrapper_depth: validateOptions.max_wrapper_depth ?? null,
+        rule_overrides: sortedRuleOverrides ?? null,
+    });
+}
+function serializeMediaSelectionOptions(mediaSelection) {
+    if (!mediaSelection) {
+        return "";
+    }
+    return JSON.stringify({
+        supportedMimeTypes: mediaSelection.supportedMimeTypes ?? null,
+        preferredMimeTypes: mediaSelection.preferredMimeTypes ?? null,
+        preferredDelivery: mediaSelection.preferredDelivery ?? null,
+        targetBitrate: mediaSelection.targetBitrate ?? null,
+        maxBitrate: mediaSelection.maxBitrate ?? null,
+        targetWidth: mediaSelection.targetWidth ?? null,
+        targetHeight: mediaSelection.targetHeight ?? null,
+    });
+}
+function createSessionConfig(options) {
+    return {
+        sourceKind: options.source.kind,
+        sourceValue: options.source.kind === "xml" ? options.source.xml : options.source.url,
+        label: options.source.label ?? null,
+        requestRef: options.source.kind === "url" ? (options.source.request ?? null) : null,
+        fetchRef: options.fetch ?? null,
+        timeoutMs: options.timeoutMs ?? null,
+        maxWrapperDepth: options.maxWrapperDepth ?? null,
+        validateOptionsKey: serializeValidateOptions(options.validateOptions),
+    };
+}
+function createPlaybackConfig(options) {
+    return {
+        sessionRef: options.session,
+        autoResolve: options.autoResolve !== false,
+        mediaSelectionKey: serializeMediaSelectionOptions(options.mediaSelection),
+    };
+}
+function createPlaybackQueueConfig(options) {
+    return {
+        sessionRef: options.session,
+        fetchRef: options.fetch ?? null,
+        autoResolve: options.autoResolve !== false,
+        mediaSelectionKey: serializeMediaSelectionOptions(options.mediaSelection),
+    };
+}
+function hasSessionConfigChanged(previous, next) {
+    return (previous.sourceKind !== next.sourceKind
+        || previous.sourceValue !== next.sourceValue
+        || previous.label !== next.label
+        || !Object.is(previous.requestRef, next.requestRef)
+        || !Object.is(previous.fetchRef, next.fetchRef)
+        || previous.timeoutMs !== next.timeoutMs
+        || previous.maxWrapperDepth !== next.maxWrapperDepth
+        || previous.validateOptionsKey !== next.validateOptionsKey);
+}
+function hasPlaybackConfigChanged(previous, next) {
+    return (!Object.is(previous.sessionRef, next.sessionRef)
+        || previous.autoResolve !== next.autoResolve
+        || previous.mediaSelectionKey !== next.mediaSelectionKey);
+}
+function hasPlaybackQueueConfigChanged(previous, next) {
+    return (!Object.is(previous.sessionRef, next.sessionRef)
+        || !Object.is(previous.fetchRef, next.fetchRef)
+        || previous.autoResolve !== next.autoResolve
+        || previous.mediaSelectionKey !== next.mediaSelectionKey);
+}
+async function runAutoAction(session, autoLoad, autoValidate) {
+    if (autoValidate) {
+        await session.validate();
+        return session.getSnapshot();
+    }
+    if (autoLoad) {
+        return session.load();
+    }
+    return session.getSnapshot();
+}
+export function useVastSession(options) {
+    const { autoLoad = true, autoValidate = false, ...sessionOptions } = options;
+    const [, forceRender] = useReducer((value) => value + 1, 0);
+    const trackedSessionRef = useRef(null);
+    const autoStartedSessionsRef = useRef(new WeakSet());
+    const sessionConfig = createSessionConfig(sessionOptions);
+    if (!trackedSessionRef.current
+        || hasSessionConfigChanged(trackedSessionRef.current.config, sessionConfig)) {
+        trackedSessionRef.current = {
+            config: sessionConfig,
+            session: createVastSession(sessionOptions),
+        };
+    }
+    const getCurrentSession = () => trackedSessionRef.current.session;
+    const replaceSession = () => {
+        const nextSession = createVastSession(sessionOptions);
+        trackedSessionRef.current = {
+            config: sessionConfig,
+            session: nextSession,
+        };
+        startTransition(() => {
+            forceRender();
+        });
+        return nextSession;
+    };
+    const session = getCurrentSession();
+    const snapshot = useSubscribedSnapshot(session);
+    useEffect(() => {
+        if ((!autoLoad && !autoValidate) || autoStartedSessionsRef.current.has(session)) {
+            return;
+        }
+        autoStartedSessionsRef.current.add(session);
+        void runAutoAction(session, autoLoad, autoValidate).catch(() => {
+            // Session state already captures errors for consumers.
+        });
+    }, [session, autoLoad, autoValidate]);
+    return {
+        session,
+        snapshot,
+        load() {
+            return getCurrentSession().load();
+        },
+        reload() {
+            const nextSession = replaceSession();
+            autoStartedSessionsRef.current.add(nextSession);
+            return runAutoAction(nextSession, true, autoValidate);
+        },
+        validate() {
+            return getCurrentSession().validate();
+        },
+        fix() {
+            return getCurrentSession().fix();
+        },
+        resolve() {
+            return getCurrentSession().resolve();
+        },
+        track(event, trackOptions) {
+            return getCurrentSession().track(event, trackOptions);
+        },
+        trackAd(adSelector, event, trackOptions) {
+            return getCurrentSession().trackAd(adSelector, event, trackOptions);
+        },
+    };
+}
+export function useVastAnnotations(_options) {
+    const deferredXml = useDeferredValue(_options.xml);
+    const deferredValidation = useDeferredValue(_options.validation);
+    return useMemo(() => buildVastAnnotationModel(deferredXml, deferredValidation), [deferredXml, deferredValidation]);
+}
+export function useVastPlayback(options) {
+    const { autoInitialize = true, ...controllerOptions } = options;
+    const trackedPlaybackRef = useRef(null);
+    const autoInitializedControllersRef = useRef(new WeakSet());
+    const playbackConfig = createPlaybackConfig(controllerOptions);
+    if (!trackedPlaybackRef.current
+        || hasPlaybackConfigChanged(trackedPlaybackRef.current.config, playbackConfig)) {
+        trackedPlaybackRef.current = {
+            config: playbackConfig,
+            controller: createVastPlaybackController(controllerOptions),
+        };
+    }
+    const getCurrentController = () => trackedPlaybackRef.current.controller;
+    const controller = getCurrentController();
+    const snapshot = useSubscribedSnapshot(controller);
+    useEffect(() => {
+        return () => {
+            controller.dispose();
+        };
+    }, [controller]);
+    useEffect(() => {
+        if (!autoInitialize || autoInitializedControllersRef.current.has(controller)) {
+            return;
+        }
+        autoInitializedControllersRef.current.add(controller);
+        void controller.initialize().catch(() => {
+            // Controller state already captures errors for consumers.
+        });
+    }, [controller, autoInitialize]);
+    return {
+        controller,
+        snapshot,
+        initialize() {
+            return getCurrentController().initialize();
+        },
+        start() {
+            return getCurrentController().start();
+        },
+        pause() {
+            return getCurrentController().pause();
+        },
+        resume() {
+            return getCurrentController().resume();
+        },
+        updateProgress(currentTimeSec, durationSec) {
+            return getCurrentController().updateProgress(currentTimeSec, durationSec);
+        },
+        complete() {
+            return getCurrentController().complete();
+        },
+        setMuted(muted) {
+            return getCurrentController().setMuted(muted);
+        },
+        setFullscreen(fullscreen) {
+            return getCurrentController().setFullscreen(fullscreen);
+        },
+        setViewability(viewability) {
+            return getCurrentController().setViewability(viewability);
+        },
+        click(trackOptions) {
+            return getCurrentController().click(trackOptions);
+        },
+        skip() {
+            return getCurrentController().skip();
+        },
+        signalError(trackOptions) {
+            return getCurrentController().signalError(trackOptions);
+        },
+    };
+}
+export function useVastPlaybackQueue(options) {
+    const { autoInitialize = true, ...controllerOptions } = options;
+    const trackedPlaybackQueueRef = useRef(null);
+    const autoInitializedControllersRef = useRef(new WeakSet());
+    const playbackQueueConfig = createPlaybackQueueConfig(controllerOptions);
+    if (!trackedPlaybackQueueRef.current
+        || hasPlaybackQueueConfigChanged(trackedPlaybackQueueRef.current.config, playbackQueueConfig)) {
+        trackedPlaybackQueueRef.current = {
+            config: playbackQueueConfig,
+            controller: createVastPlaybackQueueController(controllerOptions),
+        };
+    }
+    const getCurrentController = () => trackedPlaybackQueueRef.current.controller;
+    const controller = getCurrentController();
+    const snapshot = useSubscribedSnapshot(controller);
+    useEffect(() => {
+        return () => {
+            controller.dispose();
+        };
+    }, [controller]);
+    useEffect(() => {
+        if (!autoInitialize || autoInitializedControllersRef.current.has(controller)) {
+            return;
+        }
+        autoInitializedControllersRef.current.add(controller);
+        void controller.initialize().catch(() => {
+            // Controller state already captures errors for consumers.
+        });
+    }, [controller, autoInitialize]);
+    return {
+        controller,
+        snapshot,
+        initialize() {
+            return getCurrentController().initialize();
+        },
+        start() {
+            return getCurrentController().start();
+        },
+        pause() {
+            return getCurrentController().pause();
+        },
+        resume() {
+            return getCurrentController().resume();
+        },
+        updateProgress(currentTimeSec, durationSec) {
+            return getCurrentController().updateProgress(currentTimeSec, durationSec);
+        },
+        completeCurrent() {
+            return getCurrentController().completeCurrent();
+        },
+        next() {
+            return getCurrentController().next();
+        },
+        setMuted(muted) {
+            return getCurrentController().setMuted(muted);
+        },
+        setFullscreen(fullscreen) {
+            return getCurrentController().setFullscreen(fullscreen);
+        },
+        setViewability(viewability) {
+            return getCurrentController().setViewability(viewability);
+        },
+        click(trackOptions) {
+            return getCurrentController().click(trackOptions);
+        },
+        skip() {
+            return getCurrentController().skip();
+        },
+        signalError(trackOptions) {
+            return getCurrentController().signalError(trackOptions);
+        },
+    };
+}
+export function useVastTracker(options) {
+    const { session } = options;
+    const snapshot = useSubscribedSnapshot(session);
+    const availableEvents = useMemo(() => {
+        const events = new Set();
+        if (snapshot.tracking.plan.impressions.length > 0) {
+            events.add("impression");
+        }
+        if (snapshot.tracking.plan.errors.length > 0) {
+            events.add("error");
+        }
+        if (snapshot.tracking.plan.clickTrackings.length > 0) {
+            events.add("clickTracking");
+        }
+        for (const target of snapshot.tracking.plan.events) {
+            events.add(target.event);
+        }
+        return [...events].sort((left, right) => left.localeCompare(right));
+    }, [snapshot.tracking]);
+    return {
+        session,
+        tracking: snapshot.tracking,
+        resolvedAd: snapshot.resolvedAd,
+        resolvedAds: snapshot.resolvedAds,
+        companions: snapshot.resolvedAd?.companions ?? [],
+        availableEvents,
+        clickThroughUrl: snapshot.resolvedAd?.clickThroughUrl ?? null,
+        clickThroughUrls: snapshot.resolvedAd?.clickThroughUrls ?? [],
+        getAdCompanions(adSelector) {
+            return session.getAdCompanions(adSelector);
+        },
+        track(event, trackOptions) {
+            return session.track(event, trackOptions);
+        },
+        trackAd(adSelector, event, trackOptions) {
+            return session.trackAd(adSelector, event, trackOptions);
+        },
+        trackCompanion(adSelector, companionSelector, event, trackOptions) {
+            return session.trackCompanion(adSelector, companionSelector, event, trackOptions);
+        },
+        getTargets(event, trackOptions) {
+            return selectTrackingTargets(snapshot.tracking.plan, event, trackOptions?.offset);
+        },
+        getAdTargets(adSelector, event, trackOptions) {
+            return session.getAdTrackingTargets(adSelector, event, trackOptions);
+        },
+        getCompanionTargets(adSelector, companionSelector, event) {
+            return session.getCompanionTrackingTargets(adSelector, companionSelector, event);
+        },
+        hasTargets(event, trackOptions) {
+            return selectTrackingTargets(snapshot.tracking.plan, event, trackOptions?.offset).length > 0;
+        },
+        hasAdTargets(adSelector, event, trackOptions) {
+            return session.getAdTrackingTargets(adSelector, event, trackOptions).length > 0;
+        },
+        hasCompanionTargets(adSelector, companionSelector, event) {
+            return session.getCompanionTrackingTargets(adSelector, companionSelector, event).length > 0;
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { useVastAnnotations, useVastPlayback, useVastPlaybackQueue, useVastSession, useVastTracker } from "./hooks.js";
+export type { UseVastAnnotationsOptions, UseVastPlaybackOptions, UseVastPlaybackQueueOptions, UseVastSessionOptions, UseVastTrackerOptions, VastAnnotation, VastAnnotationModel, VastPlaybackHookResult, VastPlaybackQueueHookResult, VastSessionHookResult, VastTrackerHookResult, } from "./types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { useVastAnnotations, useVastPlayback, useVastPlaybackQueue, useVastSession, useVastTracker } from "./hooks.js";

package/dist/types.d.ts

@@ -0,0 +1,72 @@
+import type { VastPlaybackController, VastPlaybackControllerOptions, VastPlaybackSnapshot, VastPlaybackQueueController, VastPlaybackQueueControllerOptions, VastPlaybackQueueSnapshot, VastCompanionAd, VastCompanionSelector, VastAdSelector, VastResolvedAd, VastSession, VastSessionOptions, VastSessionSnapshot, VastTrackOptions, VastTrackableEvent, VastTrackingDispatchResult, VastTrackingState, VastTrackingTarget } from "vastlint-client";
+import type { FixResult, ValidationResult } from "vastlint";
+export interface UseVastSessionOptions extends VastSessionOptions {
+    autoLoad?: boolean;
+    autoValidate?: boolean;
+}
+export interface VastAnnotation {
+    id: string;
+    issueId: string;
+    severity: "error" | "warning" | "info";
+    message: string;
+    path: string | null;
+    line: number | null;
+    col: number | null;
+}
+export interface VastAnnotationModel {
+    annotations: VastAnnotation[];
+    byLine: Map<number, VastAnnotation[]>;
+    byIssueId: Map<string, VastAnnotation[]>;
+}
+export interface UseVastAnnotationsOptions {
+    xml: string;
+    validation: ValidationResult | null;
+}
+export interface UseVastTrackerOptions {
+    session: VastSession;
+}
+export interface UseVastPlaybackOptions extends VastPlaybackControllerOptions {
+    autoInitialize?: boolean;
+}
+export interface UseVastPlaybackQueueOptions extends VastPlaybackQueueControllerOptions {
+    autoInitialize?: boolean;
+}
+export interface VastTrackerHookResult {
+    session: VastSession;
+    tracking: VastTrackingState;
+    resolvedAd: VastResolvedAd | null;
+    resolvedAds: VastResolvedAd[];
+    companions: VastCompanionAd[];
+    availableEvents: VastTrackableEvent[];
+    clickThroughUrl: string | null;
+    clickThroughUrls: string[];
+    getAdCompanions(adSelector: VastAdSelector): VastCompanionAd[];
+    track(event: VastTrackableEvent, options?: VastTrackOptions): Promise<VastTrackingDispatchResult[]>;
+    trackAd(adSelector: VastAdSelector, event: VastTrackableEvent, options?: VastTrackOptions): Promise<VastTrackingDispatchResult[]>;
+    trackCompanion(adSelector: VastAdSelector, companionSelector: VastCompanionSelector, event: VastTrackableEvent, options?: VastTrackOptions): Promise<VastTrackingDispatchResult[]>;
+    getTargets(event: VastTrackableEvent, options?: Pick<VastTrackOptions, "offset">): VastTrackingTarget[];
+    getAdTargets(adSelector: VastAdSelector, event: VastTrackableEvent, options?: Pick<VastTrackOptions, "offset">): VastTrackingTarget[];
+    getCompanionTargets(adSelector: VastAdSelector, companionSelector: VastCompanionSelector, event: VastTrackableEvent): VastTrackingTarget[];
+    hasTargets(event: VastTrackableEvent, options?: Pick<VastTrackOptions, "offset">): boolean;
+    hasAdTargets(adSelector: VastAdSelector, event: VastTrackableEvent, options?: Pick<VastTrackOptions, "offset">): boolean;
+    hasCompanionTargets(adSelector: VastAdSelector, companionSelector: VastCompanionSelector, event: VastTrackableEvent): boolean;
+}
+export interface VastSessionHookResult {
+    session: VastSession;
+    snapshot: VastSessionSnapshot;
+    load(): Promise<VastSessionSnapshot>;
+    reload(): Promise<VastSessionSnapshot>;
+    validate(): Promise<ValidationResult>;
+    fix(): Promise<FixResult>;
+    resolve(): Promise<VastSessionSnapshot>;
+    track(event: VastTrackableEvent, options?: VastTrackOptions): Promise<VastTrackingDispatchResult[]>;
+    trackAd(adSelector: VastAdSelector, event: VastTrackableEvent, options?: VastTrackOptions): Promise<VastTrackingDispatchResult[]>;
+}
+export interface VastPlaybackHookResult extends Pick<VastPlaybackController, "initialize" | "start" | "pause" | "resume" | "updateProgress" | "complete" | "setMuted" | "setFullscreen" | "setViewability" | "click" | "skip" | "signalError"> {
+    controller: VastPlaybackController;
+    snapshot: VastPlaybackSnapshot;
+}
+export interface VastPlaybackQueueHookResult extends Pick<VastPlaybackQueueController, "initialize" | "start" | "pause" | "resume" | "updateProgress" | "completeCurrent" | "next" | "setMuted" | "setFullscreen" | "setViewability" | "click" | "skip" | "signalError"> {
+    controller: VastPlaybackQueueController;
+    snapshot: VastPlaybackQueueSnapshot;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "vastlint-react",
+  "version": "0.4.20",
+  "description": "Headless React hooks for vastlint-client.",
+  "license": "Apache-2.0",
+  "author": "Alex Sekowski <alex@vastlint.org>",
+  "homepage": "https://vastlint.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aleksUIX/vastlint.git",
+    "directory": "packages/vastlint-react"
+  },
+  "bugs": {
+    "url": "https://github.com/aleksUIX/vastlint/issues"
+  },
+  "keywords": [
+    "vast",
+    "vast-client",
+    "react",
+    "react-hooks",
+    "adtech",
+    "ctv",
+    "video",
+    "advertising",
+    "programmatic"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm --prefix ../vastlint-client run build && npm run build && node --test test/**/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "vastlint-client": "^0.4.20"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "jsdom": "^26.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.2.6",
+    "typescript": "^5.9.3"
+  }
+}