@evaro/consultation-sdk 0.0.0-stage → 0.1.0

package/dist/types/Consultation.d.ts

@@ -0,0 +1,24 @@
+import type { ConsultationEvent, ConsultationType, Environment, GetToken, Target } from './types';
+export interface ConsultationProps {
+    /** The hash of the consultation to show. */
+    consultation: string;
+    /** The vendor hash. It selects the theme and goes to the API, as in Connect. */
+    vendor: string;
+    environment: Environment;
+    /** Where the answers are saved. With no target the package runs as a preview and saves nothing. */
+    target?: Target;
+    /** Returns the signed-in user's token for the target's calls. */
+    getToken?: GetToken;
+    /** Shows the target's saved answers. They cannot be changed or submitted. */
+    readOnly?: boolean;
+    /** Loads the unpublished version of the consultation. */
+    preview?: boolean;
+    /** Reported as `consultation_type` on the events. Defaults to the consultation's own type. */
+    consultationType?: ConsultationType;
+    /** Called when the flow ends: after submit, or when the user closes the knockout screen. */
+    onDone?: () => void;
+    /** Receives the analytics signals, with the names and fields Connect uses. */
+    onEvent?: (event: ConsultationEvent) => void;
+}
+export declare const DRAFT_DELAY_MS = 600;
+export declare function Consultation(props: ConsultationProps): import("react").JSX.Element;

package/dist/types/api.d.ts

@@ -0,0 +1,15 @@
+import type { Environment } from './types';
+export declare const apiHost: (environment: Environment) => string;
+export declare const nodeApiHost: (environment: Environment) => string;
+export declare class RequestError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export declare function requestJson<T>(url: string, init?: RequestInit): Promise<T>;
+export interface VendorTheme {
+    colours?: Partial<Record<'100' | '300' | '500' | '700' | '900', string>>;
+}
+/** The consultation as Connect loads it. `preview` reads the unpublished version, which needs no token. */
+export declare function fetchVendorConsultation(environment: Environment, hash: string, vendor: string, preview: boolean): Promise<iConsultation>;
+/** The vendor's colours, loaded once for each vendor. A missing theme leaves Connect's default palette. */
+export declare function fetchVendorTheme(environment: Environment, vendor: string): Promise<VendorTheme | null>;

package/dist/types/events.d.ts

@@ -0,0 +1,15 @@
+import type { ConsultationEvent, ConsultationType } from './types';
+export interface EventContext {
+    consultationHash: string;
+    experimentOf: string | undefined;
+    consultationType: ConsultationType;
+}
+/** Builds the signals with the same names and fields as Connect's `utils/analytics.ts`. */
+export declare const consultationEvents: (context: EventContext) => {
+    started: () => ConsultationEvent;
+    completed: () => ConsultationEvent;
+    exited: () => ConsultationEvent;
+    viewed: (number: number, all: number) => ConsultationEvent;
+    questionViewed: (hash: string, skipped?: boolean) => ConsultationEvent;
+    questionAnswered: (hash: string, skipped?: boolean) => ConsultationEvent;
+};

package/dist/types/flow/answer.d.ts

@@ -0,0 +1,46 @@
+export type AnswerValue = string | string[];
+export type AnswerMap = Record<string, AnswerValue>;
+type OptionLogic = iQuestion['options'][number]['logic'];
+/** Types that wait for Continue: free text, multi-select and types with their own input. */
+export declare const NON_AUTO_PROGRESS_TYPES: string[];
+export interface AnswerState {
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+}
+export type Navigation = {
+    kind: 'none';
+} | {
+    kind: 'next';
+} | {
+    kind: 'goto';
+    hash: string;
+};
+export interface AnswerResult extends AnswerState {
+    /** The jump to hold until Continue. `undefined` leaves the current one. */
+    nextOverride: string | null | undefined;
+    navigation: Navigation;
+}
+interface AnswerInput {
+    question: iQuestion;
+    state: AnswerState;
+    value: AnswerValue;
+    logic?: OptionLogic;
+    /** False for a follow-up that is not the last of its group, or while one above it is blank. */
+    ownsProgression: boolean;
+}
+/**
+ * Where a checkbox answer jumps: the first ticked option that has a go-to. The shared next-question rule takes
+ * the first ticked option and then reads its go-to, which misses a jump on a later option.
+ */
+export declare function checkboxJump(question: iQuestion | undefined, answer: AnswerValue | null | undefined, optionHash?: AnswerValue | null): string | null;
+/**
+ * The jump the live flow holds for Continue on a question: one set in an open follow-up, then a checkbox jump
+ * on the main question. A main radio's own go-to is left to the shared next-question rule.
+ *
+ * The live flow keeps the jump of the last click, and click order is not saved, so a later follow-up in the
+ * group wins here. The two differ only when two open follow-ups both hold a jump, or one clears another's.
+ */
+export declare function heldJump(question: iQuestion, allQuestions: iQuestion[], answers: AnswerMap, optionHashes?: AnswerMap): string | null;
+/** Applies one answer. Returns null when the click changes nothing, such as the same radio option again. */
+export declare function applyAnswer({ question, state, value, logic, ownsProgression }: AnswerInput): AnswerResult | null;
+export {};

package/dist/types/flow/path.d.ts

@@ -0,0 +1,27 @@
+import { type AnswerMap } from './answer';
+/**
+ * Only the answers on the path the user took. Going Back and choosing another option leaves the answers of the
+ * old branch in state; they must not be saved as if they were given on this path.
+ */
+export declare function answersOnPath(history: string[], allQuestions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap): AnswerMap;
+/** The consultation and the answers that a walk through the flow follows. */
+export interface Walk {
+    allQuestions: iQuestion[];
+    visibleQuestions: iQuestion[];
+    consultationHash: string;
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+}
+/**
+ * Where a saved draft opens: walks the flow from the first question while each one holds a complete answer.
+ * Returns the questions passed on the way, with the one to show last.
+ */
+export declare function resumeHistory(walk: Walk): string[];
+/**
+ * The answers a draft keeps: the path behind the user, and ahead of them the questions the current answers
+ * still lead to. After Back, answers further on survive while the user edits, even when an edit leaves the
+ * current question unfinished. Answers of a branch the user left are dropped.
+ */
+export declare function draftAnswers(history: string[], walk: Walk): AnswerMap;
+/** Whether every question on the path has a complete answer, so the answers can be submitted. */
+export declare function isPathComplete(history: string[], allQuestions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap): boolean;

package/dist/types/flow/questionnaire.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Pure logic functions for the questionnaire consultation flow.
+ * Used by QuestionnaireManager and Question so the behaviour lives in one place.
+ */
+/**
+ * Returns only the questions that should be visible to the patient:
+ * - excludes follow-up questions (shown inline)
+ * - excludes questions whose hash is in the hidden-answers map
+ * - excludes questions that don't apply to the patient's age or gender
+ */
+export declare function filterVisibleQuestions(questions: iQuestion[], hiddenAnswers: Record<string, unknown>, demographics?: PatientDemographics | null): iQuestion[];
+/** Age and gender known before the consultation starts, when the patient is picked or described up front. */
+export interface PatientDemographics {
+    age: number | null;
+    gender: 'male' | 'female' | null;
+}
+/**
+ * Whether a question doesn't apply to the patient. Questions carry no age or gender conditions yet, so
+ * nothing is hidden; the rules go here once the API sends them.
+ */
+export declare function isHiddenForPatient(_question: iQuestion, _demographics: PatientDemographics | null): boolean;
+/**
+ * Clears every jump naming a question the list no longer holds, so the flow falls through in order rather
+ * than opening one that cannot render. Follow-ups too: a pending one that renders nothing holds Continue shut.
+ */
+export declare function withReachableJumps(questions: iQuestion[]): iQuestion[];
+/**
+ * A `dosage` question is an unanswerable template until the API expands it under the same hash, as a radio.
+ * One that never expanded is dropped — nothing renders the type — and jumps aimed at it are cleared with it.
+ */
+export declare function withExpandedDosage(questions: iQuestion[], expanded?: iQuestion | null): iQuestion[];
+/**
+ * Whether the flow can open this question — for the `q` in the URL, the one hash nothing upstream vets.
+ * Plain membership, so hand it the visible set: a follow-up is asked inline and a carried answer is hidden,
+ * and neither has a screen of its own.
+ */
+export declare function isRenderableQuestion(hash: string | null | undefined, questions: iQuestion[]): hash is string;
+/**
+ * The BMI range a reading falls in. Ranges may share a bound (24-27 then 27-28), and the later one
+ * takes the shared value, so the patient's feedback and their routing agree on which range applies.
+ */
+export declare function findBmiRange(options: iQuestion['options'] | undefined, bmi: number): iQuestion['options'][number] | undefined;
+/** The BMI a stored answer carries (`height=…cm weight=…kg bmi=…`), or null when it has none. */
+export declare function bmiFromAnswer(answer: string | string[] | null | undefined): number | null;
+/**
+ * Determines which question to navigate to next. Throws when questionIndex is negative.
+ * Priority order:
+ *   1. nextQuestionHashOverride (set by inline follow-up logic)
+ *   2. the go-to on the answered option, or on the range a BMI answer falls in
+ *   3. consultation-level logic.next on the current question
+ *   4. the standard next question in sequence
+ *
+ * The final branch reads `.hash` off the next question directly (no optional
+ * chaining) so an out-of-bounds index throws here, at the source, rather than
+ * silently returning undefined and crashing a component further down.
+ */
+export declare function resolveNextQuestionHash(questions: iQuestion[], questionIndex: number, nextQuestionHashOverride: string | null, currentQuestion: iQuestion | undefined, consultationHash: string, answer?: string | string[] | null): string;
+/**
+ * Where a navigation target lands once hidden questions are taken into account:
+ * the target itself when visible, else the first visible question after both the
+ * target and the current question in consultation order, else null. A follow-up
+ * or unknown target continues after the current question.
+ */
+export declare function resolveVisibleTarget(allQuestions: iQuestion[], visibleQuestions: iQuestion[], targetHash: string, currentHash?: string | null): string | null;
+type Option = iQuestion['options'][0];
+type OptionLogic = Option['logic'];
+/**
+ * Whether an option is the current answer — matched by option hash (primary)
+ * or by label (backward-compatibility fallback).
+ */
+export declare function isOptionSelected(option: Option, answer: string | string[] | null | undefined, answerOptionHash: string | string[] | null | undefined): boolean;
+/**
+ * Returns the logic entries for whichever options match the current answer.
+ * Handles both single-value (radio) and multi-value (checkbox) answers.
+ */
+export declare function getMatchedOptionLogics(answer: string | string[] | null | undefined, answerOptionHash: string | string[] | null | undefined, options: iQuestion['options']): OptionLogic[];
+/**
+ * Collects all inline follow-up question hashes from the active logics,
+ * de-duplicating so each follow-up appears once.
+ */
+export declare function getFollowUpHashes(logics: OptionLogic[]): string[];
+/** Whether an option logic carries an exit condition. */
+export declare function hasExitLogic(logic: OptionLogic | undefined): boolean;
+export declare const FREE_TEXT_TYPES: string[];
+/** Free text needs enough to be worth reading, so a stray character does not unlock Continue. */
+export declare function isFreeTextTooShort(type: string, answer: string | string[] | null | undefined): boolean;
+type AnswerMap = Record<string, string | string[]>;
+/** Whether every follow-up in the group is answered, walking nested ones. `seen` guards a chain that loops back. */
+export declare function areFollowUpsAnswered(followUpHashes: string[], questions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap, seen?: Set<string>): boolean;
+/**
+ * Every top-level question, plus the follow-ups the selected options open, walking nested ones.
+ * Jumps (`logic.next`) are not followed, so a top-level question the run skipped still counts as reached.
+ */
+export declare function reachableQuestionHashes(questions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap): Set<string>;
+/**
+ * Decides whether the Continue button should be rendered:
+ *   - there is an answer
+ *   - no exit condition is triggered
+ *   - no inline follow-up questions are pending
+ *   - the question type doesn't auto-navigate (radio) or has its own submit (uploader)
+ *   - date fields must be fully filled (length === 10 for DD-MM-YYYY)
+ *   - the answer passes validation
+ */
+export declare function shouldShowButton(type: string, answer: string | string[] | null | undefined, exitQuestion: OptionLogic | undefined, followUpHashes: string[], hasValidationError: boolean | null | undefined): boolean;
+/**
+ * Computes the new checkbox answer when a value is toggled.
+ * - If the value is already in the array it is removed.
+ * - If it is not, it is appended.
+ * - Returns null when the resulting array is empty (clears the answer).
+ */
+export declare function applyCheckboxToggle(currentAnswer: string | string[] | null | undefined, value: string): string[] | null;
+/**
+ * The microcopy shown above the answer options, telling the patient how the answer
+ * behaves. Set by the answer type rather than authored per question, so every
+ * consultation reads the same way. Types not listed have no hint.
+ */
+export declare function inputHintFor(type: string): string | null;
+/**
+ * CMS HTML with its non-breaking spaces made ordinary. Copy pasted into the editor can arrive
+ * with every space non-breaking, which leaves a line nowhere to wrap but mid-word.
+ */
+export declare function withBreakableSpaces(html: string | null | undefined): string;
+/**
+ * The flags an answer raises, derived from the answer itself: those on the options the
+ * patient has picked, plus the `flags_unselected` of the options they left alone. A
+ * clinical flag sometimes turns on an absent answer, and an option can only flag itself
+ * when chosen. Deriving both sides from the selection means the stored flags always match
+ * the stored answer, rather than only the option that was clicked last.
+ */
+export declare function collectFlags(selectedLabels: string[], options: iQuestion['options'] | undefined): string[] | null;
+/** Where "Review answer" returns to. Same-origin paths only, since the value arrives in the URL; null leaves the caller on its own path. */
+export declare function resolveExitReturnUrl(returnTo: string | undefined | null, mainQuestionHash: string | undefined | null): string | null;
+export {};

package/dist/types/flow/useConsultationFlow.d.ts

@@ -0,0 +1,36 @@
+import type { ConsultationEvent, ConsultationType } from '../types';
+import { type AnswerMap, type AnswerValue } from './answer';
+type OptionLogic = iQuestion['options'][number]['logic'];
+export interface ExitState {
+    questionHash: string;
+    title: string | null;
+    content: string | null;
+}
+export type Phase = 'question' | 'exit' | 'complete';
+interface Options {
+    consultation: iConsultation;
+    consultationType: ConsultationType;
+    initialAnswers: AnswerMap;
+    /** False when a saved draft is reopened, so the start is not counted twice. */
+    isNewStart: boolean;
+    emit: (event: ConsultationEvent) => void;
+}
+export declare function useConsultationFlow({ consultation, consultationType, initialAnswers, isNewStart, emit }: Options): {
+    allQuestions: iQuestion[];
+    questions: iQuestion[];
+    current: string;
+    questionIndex: number;
+    history: string[];
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+    phase: Phase;
+    exit: ExitState;
+    revision: number;
+    canGoBack: boolean;
+    answer: (question: iQuestion, value: AnswerValue, logic: OptionLogic | undefined, ownsProgression: boolean) => void;
+    nextQuestion: () => void;
+    back: () => void;
+    reviewExitAnswer: () => void;
+    restart: () => void;
+};
+export {};

package/dist/types/flow/validations.d.ts

@@ -0,0 +1,6 @@
+export declare const questionValidations: Record<string, {
+    validate: (value: string) => boolean;
+    errorMessage: string;
+    placeholder: string;
+    label: string;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export { Consultation, type ConsultationProps } from './Consultation';
+export type { Answer, Answers, ConsultationEvent, ConsultationEventName, ConsultationType, Environment, GetToken, SavedAnswers, Target, TargetAdapter } from './types';

package/dist/types/sanitize.d.ts

@@ -0,0 +1,2 @@
+/** Question and option text is HTML written in CB, so it is cleaned before it renders. Never use it for answers. */
+export declare const sanitize: (html: string | null | undefined) => string;

package/dist/types/targets/diagnosisRequest.d.ts

@@ -0,0 +1,3 @@
+import type { Environment, GetToken, TargetAdapter } from '../types';
+/** Assessment answers stored on a diagnosis request, through NodeAPI with the Prescriber App user's token. */
+export declare function diagnosisRequestTarget(environment: Environment, id: string, getToken: GetToken): TargetAdapter;

package/dist/types/targets/index.d.ts

@@ -0,0 +1,3 @@
+import type { Environment, GetToken, Target, TargetAdapter } from '../types';
+/** One adapter for each target type. To save answers in a new place, add a type here, not code in the host. */
+export declare function createTargetAdapter(target: Target, environment: Environment, getToken: GetToken): TargetAdapter;

package/dist/types/types.d.ts

@@ -0,0 +1,67 @@
+export type Environment = 'development' | 'staging' | 'production';
+/** An answer in Connect's format: option labels for choice types, text for the rest, `DD-MM-YYYY` for a date. */
+export type Answer = string | string[];
+export type Answers = Record<string, Answer>;
+/** Where the answers are saved. With no target the package runs as a preview and saves nothing. */
+export type Target = {
+    type: 'diagnosis-request';
+    id: string;
+};
+export type GetToken = () => Promise<string | null> | string | null;
+export type ConsultationType = 'treatment' | 'renew' | 'reorder' | 'review' | 'care' | (string & {});
+/** Saved answers as a target returns them. */
+export interface SavedAnswers {
+    answers: Answers;
+    status: 'empty' | 'draft' | 'submitted';
+    /** The consultation version the answers were given against, when the target knows it. */
+    consultationVersion: string | null;
+    submittedAt: string | null;
+}
+/** The calls the package makes for one target type. The adapter is the only code that knows the endpoints. */
+export interface TargetAdapter {
+    load: () => Promise<SavedAnswers>;
+    saveDraft: (answers: Answers) => Promise<void>;
+    submit: (answers: Answers) => Promise<void>;
+}
+interface ConsultationFields {
+    questionnaire_hash: string;
+    experiment_of: string | undefined;
+    consultation_type: ConsultationType;
+}
+interface QuestionFields {
+    question_hash: string;
+    consultation_hash: string;
+    is_skipped: boolean;
+    experiment_of: string | undefined;
+    consultation_type: ConsultationType;
+}
+/**
+ * An analytics signal. The names and fields are the ones Connect sends, so a host can forward them as they are.
+ * The package does not send them anywhere itself.
+ */
+export type ConsultationEvent = {
+    name: 'consultation_started';
+    data: ConsultationFields;
+} | {
+    name: 'consultation_viewed';
+    data: {
+        question_number: string;
+        question_number_of_total: string;
+    };
+} | {
+    name: 'question_viewed';
+    data: QuestionFields;
+} | {
+    name: 'question_answered';
+    data: QuestionFields;
+} | {
+    name: 'consultation_completed';
+    data: ConsultationFields;
+} | {
+    name: 'consultation_exited';
+    data: {
+        questionnaire_hash: string;
+    };
+};
+export type ConsultationEventName = ConsultationEvent['name'];
+export {};

package/dist/types/ui/Knockout.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    title: string | null;
+    content: string | null;
+    onReview: () => void;
+    onClose?: () => void;
+}
+export declare const Knockout: ({ title, content, onReview, onClose }: Props) => import("react").JSX.Element;
+export {};

package/dist/types/ui/Question.d.ts

@@ -0,0 +1,21 @@
+import type { AnswerMap, AnswerValue } from '../flow/answer';
+type OptionLogic = iQuestion['options'][number]['logic'];
+/** The types this version can fill in. The rest show a notice. */
+export declare const FILL_TYPES: string[];
+interface Props {
+    hash: string;
+    consultationHash: string;
+    questions: iQuestion[];
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+    onAnswer: (question: iQuestion, value: AnswerValue, logic: OptionLogic | undefined, ownsProgression: boolean) => void;
+    onContinue: () => void;
+    isMainQuestion?: boolean;
+    isLastFollowUp?: boolean;
+    precedingFollowUpsAnswered?: boolean;
+    disabled?: boolean;
+    /** In a preview a type this version cannot fill in can be skipped, so the rest of the flow stays reachable. */
+    allowSkipUnsupported?: boolean;
+}
+export declare const Question: ({ hash, consultationHash, questions, answers, optionHashes, onAnswer, onContinue, isMainQuestion, isLastFollowUp, precedingFollowUpsAnswered, disabled, allowSkipUnsupported }: Props) => import("react").JSX.Element;
+export {};

package/dist/types/ui/ReadOnlyAnswers.d.ts

@@ -0,0 +1,9 @@
+/** Saved answers, one question after another. Every type shows its answer, including the ones that cannot be filled in here. */
+import type { AnswerMap } from '../flow/answer';
+interface Props {
+    questions: iQuestion[];
+    answers: AnswerMap;
+    submittedAt: string | null;
+}
+export declare const ReadOnlyAnswers: ({ questions, answers, submittedAt }: Props) => import("react").JSX.Element;
+export {};

package/dist/types/ui/ShadowRoot.d.ts

@@ -0,0 +1,6 @@
+import { type CSSProperties, type ReactNode } from 'react';
+/** Renders the children in a shadow root with the package CSS, so the host CSS and the package CSS do not touch. */
+export declare const ShadowRoot: ({ children, style }: {
+    children: ReactNode;
+    style?: CSSProperties;
+}) => import("react").JSX.Element;

package/dist/types/ui/primitives.d.ts

@@ -0,0 +1,37 @@
+import type React from 'react';
+import { type ReactNode } from 'react';
+export declare const CircularProgress: ({ size, className }: {
+    size?: number;
+    className?: string;
+}) => React.JSX.Element;
+export declare const CheckCircleIcon: ({ className }: {
+    className?: string;
+}) => React.JSX.Element;
+export declare const EmptyCircleIcon: () => React.JSX.Element;
+export declare const ArrowLeftIcon: () => React.JSX.Element;
+interface ButtonProps extends React.ComponentProps<'button'> {
+    variant?: 'text' | 'contained' | 'outlined' | 'consultation';
+    color?: 'primary' | 'secondary' | 'success';
+    fullWidth?: boolean;
+    loading?: boolean;
+    startIcon?: ReactNode;
+}
+export declare const Button: ({ variant, color, fullWidth, children, className, startIcon, disabled, loading, type, ...rest }: ButtonProps) => React.JSX.Element;
+export interface TextFieldProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    error?: boolean;
+    label?: string;
+    helperText?: string;
+    multiline?: boolean;
+    rows?: number;
+    labelClassName?: string;
+}
+export declare const TextField: React.ForwardRefExoticComponent<TextFieldProps & React.RefAttributes<HTMLInputElement>>;
+/** A masked `DD-MM-YYYY` text field, as in Connect. It needs no popover, so it works inside a shadow root. */
+export declare const DatePicker: ({ onChange, ...props }: Omit<TextFieldProps, 'onChange'> & {
+    onChange: (value: string) => void;
+}) => React.JSX.Element;
+export declare const Accordion: ({ title, description }: {
+    title: string;
+    description: string;
+}) => React.JSX.Element;
+export {};

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@evaro/consultation-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The Evaro consultation flow as a React component: one question at a time, follow-ups, jumps and the knockout screen.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TotalAccessHealth/consultation.git",
+    "directory": "sdk"
+  },
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "scripts": {
+    "prepublishOnly": "pnpm -C .. build:sdk && pnpm -C .. test:sdk"
+  }
+}