@petrarca/sonnet-core 0.7.0 → 0.9.0

package/dist/types-HhzIKd1R.d.ts

@@ -0,0 +1,582 @@
+/**
+ * $ref Resolution -- resolves JSON Schema references.
+ *
+ * Walks the schema tree and replaces `{ "$ref": ... }` nodes with the
+ * corresponding sub-schema. By default it resolves local, in-document refs:
+ * `#/$defs/name` (Draft 2020-12) or `#/definitions/name` (Draft 7).
+ *
+ * A caller may inject a `RefResolver` to resolve ANY ref string (e.g. a schema
+ * registry id like `sdf_...`, or a canonical URI). The injected resolver is
+ * tried first, then the core types (coreTypes.ts), then the in-document
+ * `$defs`/`definitions` lookup, so every ref style works together. The resolver is synchronous: consumers that
+ * fetch schemas asynchronously (e.g. from a registry over HTTP) pre-load them
+ * into a map and pass a `(ref) => map[ref]` lookup. This keeps the toolkit pure
+ * (no HTTP, no async).
+ *
+ * Keywords beside the `$ref` apply with the target, as in 2020-12: they are
+ * merged on top of it -- a custom title -- and `properties` key by key,
+ * `required` as both lists, so a node narrows a property of the target (a
+ * quantity's units) without restating the rest. Refs that no resolver can
+ * satisfy are left as-is.
+ */
+
+/** Resolve a `$ref` string to its target sub-schema, or undefined if unknown. */
+type RefResolver = (ref: string) => JsonSchemaProperty | undefined;
+/**
+ * Resolve `$ref` pointers in a JSON Schema document.
+ *
+ * By default resolves the core types and in-document `#/$defs` /
+ * `#/definitions` refs. Pass a `resolve` to also resolve registry/URI refs; it
+ * is tried first, the core types and the in-document lookup after it. The original schema is never mutated;
+ * a document with no refs to resolve is returned unchanged.
+ */
+declare function resolveRefs(schema: JsonSchema, resolve?: RefResolver): JsonSchema;
+
+/**
+ * Core types -- value types with one definition each, shared by every schema
+ * that uses them: a property is one by `$ref` to the type's id, and narrows it
+ * beside the `$ref` (a quantity's units). The ids are identifiers, never
+ * fetched: the definitions ship here and resolve without a server, before an
+ * injected resolver's and the in-document ones.
+ *
+ * The first is a quantity, aligned with FHIR's `Quantity` and openEHR's
+ * `DV_QUANTITY`: a number and a unit code -- UCUM unless `system` says
+ * otherwise -- and, optionally, a comparator. The unit's label is not stored:
+ * the question's units give it. See docs/design/core-types.md.
+ */
+
+/**
+ * A value type: a value with one definition that schemas use by `$ref` to its
+ * id. Sonnet contributes the core types; an application contributes its own,
+ * with an id of its own. See docs/design/value-types.md (workspace).
+ */
+interface ValueType {
+    /** The `$ref` id -- whose type it is is part of it. */
+    id: string;
+    /** What it is called where an author sees it. */
+    label: string;
+    /** What the `$ref` resolves to: its shape, validation and widget hint. */
+    definition: JsonSchemaProperty;
+}
+/** Where the core types' ids live. */
+declare const CORE_TYPES_BASE = "https://schemas.petrarca-labs.com/core/";
+/** The id of the quantity type, version 1. */
+declare const QUANTITY_TYPE_ID = "https://schemas.petrarca-labs.com/core/quantity/v1";
+/** UCUM, the unit system a quantity's unit is in when it names none. */
+declare const UCUM_SYSTEM = "http://unitsofmeasure.org";
+/** How a quantity's value relates to the actual one: "less than 5". */
+type QuantityComparator = "<" | "<=" | ">=" | ">";
+/** A quantity: a number and a unit code (UCUM unless `system` says otherwise). */
+interface Quantity {
+    value: number;
+    unit: string;
+    system?: string;
+    comparator?: QuantityComparator;
+}
+/** The quantity type: a number and a unit code. */
+declare const QUANTITY_TYPE: ValueType;
+/** The id of the coded value type, version 1. */
+declare const CODING_TYPE_ID = "https://schemas.petrarca-labs.com/core/coding/v1";
+/**
+ * A coded value: a code from a code list, its code system, optionally the
+ * list's version and the label shown -- FHIR's `Coding`, a SKOS concept, a
+ * schema.org `DefinedTerm`. The label is stored: it records what was shown.
+ * A service may carry a field of its own on a coding (an internal key).
+ */
+interface Coding {
+    system: string;
+    code: string;
+    version?: string;
+    display?: string;
+}
+/** A coding's identity -- its system and code, `system|code`: what tells codings apart, never their label. */
+declare function codingKey(c: Pick<Coding, "code"> & {
+    system?: string;
+}): string;
+/** The coded value type: a code from a code list, searched through a terminology service. */
+declare const CODING_TYPE: ValueType;
+/** The id of the codeable concept type, version 1. */
+declare const CODEABLE_CONCEPT_TYPE_ID = "https://schemas.petrarca-labs.com/core/codeable-concept/v1";
+/** How a coding relates to a concept's first coding -- openEHR's `=` `>` `<`, SKOS's exact / broad / narrow match. */
+type CodingMatch = "equivalent" | "broader" | "narrower";
+/** One coding of a codeable concept: a coding, whether a person picked it, how it relates to the first, why it is there. */
+interface ConceptCoding extends Coding {
+    /** Picked by a person -- FHIR's meaning; a coding a service mapped is not. */
+    userSelected?: boolean;
+    /** How it relates to the concept's first coding; none: nobody said. */
+    match?: CodingMatch;
+    /** Why it is there -- billing, a registry. */
+    purpose?: Coding;
+}
+/**
+ * A codeable concept: one concept, coded where it can be -- in as many code
+ * systems as it needs -- or given by its text alone. FHIR's `CodeableConcept`,
+ * openEHR's `DV_CODED_TEXT` with its mappings, ISO 21090's `CD`. See
+ * docs/design/codeable-concepts.md (workspace).
+ */
+interface CodeableConcept {
+    codings?: ConceptCoding[];
+    /** What the person saw or said -- or the answer, when no code fits. */
+    text?: string;
+}
+/** The codeable concept type: one concept in several code systems, or its text alone. */
+declare const CODEABLE_CONCEPT_TYPE: ValueType;
+/** The core types: the value types sonnet contributes. */
+declare const CORE_VALUE_TYPES: readonly ValueType[];
+/** A resolver for value types' `$ref`s -- an application's, handed to the form renderer. */
+declare function valueTypeResolver(types: readonly ValueType[]): RefResolver;
+/** The definition of a core type, by its id; undefined for another ref. */
+declare function coreType(ref: string): JsonSchemaProperty | undefined;
+/** The core type a property is, by its `$ref`; undefined when it is none. */
+declare function coreTypeOf(prop: JsonSchemaProperty): string | undefined;
+
+/**
+ * Bindings -- a field's binding to a code list: `x-binding`, declared by
+ * sonnet-core beside the `x-ui-*` vocabulary. Which list (a value set or a
+ * code system, by an identifier the terminology service resolves), optionally
+ * its version, and how strictly: `required` -- only the list's codes -- or
+ * `extensible` -- another code, or a text of one's own, when none fits. A
+ * codeable concept's binding names more lists, `additional`: where its other
+ * codings come from. See docs/design/coded-values.md and
+ * docs/design/codeable-concepts.md (workspace).
+ */
+
+/** How strictly a field takes its list. */
+type BindingStrength = "required" | "extensible";
+/** One more list of a codeable concept: where another of its codings comes from (FHIR R5 `binding.additional`). */
+interface AdditionalBinding {
+    valueSet?: string;
+    system?: string;
+    version?: string;
+    /** What the list is called where an author or a person sees it (FHIR R5 `shortDoco`). */
+    title?: string;
+    /** A value must have a coding of this list, picked or mapped. */
+    required?: boolean;
+    /** Why its coding is there -- billing, a registry: the purpose of the coding it gives. */
+    purpose?: Coding;
+}
+/** A field's binding to a code list -- a codeable concept's, to more lists. */
+interface Binding {
+    valueSet?: string;
+    system?: string;
+    version?: string;
+    /** What the first list is called where it is shown beside others -- a codeable concept's. */
+    title?: string;
+    strength: BindingStrength;
+    /** A codeable concept's further lists, after the first. */
+    additional?: AdditionalBinding[];
+}
+/** The binding a property declares; undefined when it has none, or not one of this shape. */
+declare function bindingOf(prop: JsonSchemaProperty): Binding | undefined;
+/** The lists of a binding in their order: the first, then the additional ones. */
+declare function bindingLists(binding: Binding): AdditionalBinding[];
+/**
+ * A code as a condition names it: `code`, of the code system the binding names,
+ * or FHIR's token `system|code` when of another. Read here.
+ */
+declare function parseCodeToken(token: string, bound: string | undefined): {
+    system?: string;
+    code: string;
+};
+/** A code as a condition names it: its code alone when of the bound code system, else `system|code`. */
+declare function codeToken(coding: {
+    system?: string;
+    code: string;
+}, bound: string | undefined): string;
+
+/**
+ * Generic JSON Schema type definitions.
+ *
+ * These types follow Draft 2020-12 and include x-ui-* extension points
+ * for form/widget integration. They are domain-agnostic -- no
+ * application-specific entity concepts live here.
+ */
+/**
+ * A declarative presentation rule (JSONForms-style) attached to a field.
+ *
+ * The rule lives on the field it controls (the target). Its `condition` points
+ * at another field's value via a JSON Pointer (RFC 6901) into the form DATA
+ * (rooted at the whole form), and validates that value against `condition.schema`.
+ * When the condition holds, `effect` is applied to the target:
+ *  - "show"   -- render only when the condition holds
+ *  - "hide"   -- render only when the condition does NOT hold
+ *  - "enable" -- interactive only when the condition holds
+ *  - "disable"-- non-interactive when the condition holds
+ *
+ * Example: show `pregnancy_status` when `gender` equals "female":
+ * ```json
+ * { "effect": "show",
+ *   "condition": { "scope": "/gender", "schema": { "const": "female" } } }
+ * ```
+ * Unlike if/then/else, the target field stays declared at its own position, so
+ * layout placement is stable.
+ */
+interface UIRuleCondition {
+    /** JSON Pointer (RFC 6901) into the form data, e.g. "/gender" or "/patient/gender". */
+    scope: string;
+    /** Schema the value at `scope` is validated against (e.g. { const: "female" }). */
+    schema: JsonSchemaProperty;
+}
+type UIRuleEffect = "show" | "hide" | "enable" | "disable";
+interface UIRule {
+    effect: UIRuleEffect;
+    condition: UIRuleCondition;
+}
+/**
+ * A named validator reference carried by `x-ui-validate`. The bare-string form
+ * is the no-config common case (`"ibanValid"`); the object form supplies
+ * per-reference config and, for async form validators, the inputs that trigger
+ * a re-run (`dependsOn`). See the custom-validation design in sonnet-forms.
+ */
+interface UIValidateRef {
+    /** Registered validator name, resolved against the ValidatorRegistry. */
+    name: string;
+    /** Per-reference config, passed to the validator as `ctx.args`. */
+    args?: Record<string, unknown>;
+    /**
+     * For an async FORM validator: the field names whose values trigger a re-run.
+     * The engine keys/debounces the async result on these values. Ignored for
+     * sync validators and for field validators.
+     */
+    dependsOn?: string[];
+}
+/**
+ * The value of `x-ui-validate`: one validator or a list. On a property it
+ * selects field validators (`(value, ctx) => ...`); on the root object it
+ * selects form validators (`(data, ctx) => FieldError[]`). A bare string is
+ * shorthand for `{ name }`.
+ */
+type UIValidate = string | UIValidateRef | Array<string | UIValidateRef>;
+/**
+ * JSON Schema property definition following Draft 2020-12 specification.
+ * Supports basic types, validation constraints, conditionals, and custom extensions.
+ */
+type JsonSchemaProperty = {
+    type?: "string" | "number" | "integer" | "boolean" | "array" | "object" | "null";
+    title?: string;
+    description?: string;
+    default?: any;
+    /** The value is shown, not entered (Draft 2020-12 meta-data vocabulary). */
+    readOnly?: boolean;
+    const?: any;
+    enum?: any[];
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    /** The earliest / latest value of a formatted string -- a date, a time, a datetime (ajv-formats). */
+    formatMinimum?: string;
+    formatMaximum?: string;
+    items?: JsonSchemaProperty;
+    /** An array with at least one item matching it. */
+    contains?: JsonSchemaProperty;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchemaProperty;
+    $ref?: string;
+    "x-binding"?: Binding;
+    $defs?: Record<string, JsonSchemaProperty>;
+    definitions?: Record<string, JsonSchemaProperty>;
+    allOf?: JsonSchemaProperty[];
+    anyOf?: JsonSchemaProperty[];
+    oneOf?: JsonSchemaProperty[];
+    not?: JsonSchemaProperty;
+    /**
+     * Discriminator for a `oneOf` union (OpenAPI convention). `propertyName` is
+     * the shared property whose `const` value tags the active branch. When
+     * absent, the discriminator is auto-detected as the property that is const
+     * in every branch.
+     */
+    discriminator?: {
+        propertyName: string;
+    };
+    if?: JsonSchemaProperty;
+    then?: JsonSchemaProperty;
+    else?: JsonSchemaProperty;
+    "x-ui-order"?: string[];
+    "x-ui-rule"?: UIRule;
+    "x-ui-widget"?: string;
+    "x-ui-options"?: Record<string, any>;
+    "x-ui-layout"?: UILayoutConfig;
+    "x-ui-title"?: string;
+    "x-ui-placeholder"?: string;
+    "x-ui-description"?: string;
+    "x-ui-validate"?: UIValidate;
+    "x-ui-column"?: {
+        /**
+         * Display order (ascending). Properties without an order are appended
+         * after the ordered ones, keeping their schema declaration order.
+         */
+        order?: number;
+        /** Exclude this column from the table entirely. */
+        hidden?: boolean;
+        /** Fixed column width in pixels. */
+        width?: number;
+        /** Minimum column width in pixels. */
+        minWidth?: number;
+        /**
+         * The data source can order by this column. EntityTable makes its header a
+         * sort control when the table is given sorting state -- the order itself is
+         * the consumer's query, never a sort of the rows on the page.
+         */
+        sortable?: boolean;
+    };
+    /** Cell renderer name. Inferred from type+format when absent. */
+    "x-ui-cell"?: string;
+    /** Cell renderer configuration options (colors, href template, etc.). */
+    "x-ui-cell-options"?: Record<string, unknown>;
+};
+/**
+ * JSON Schema following Draft 2020-12 specification.
+ *
+ * This is the generic base type. Domain-specific consumers extend it
+ * with their own x-* extension keys via intersection types in their
+ * own type files.
+ */
+type JsonSchema = {
+    $schema?: string;
+    title: string;
+    description?: string;
+    type: "object";
+    properties: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchemaProperty;
+    allOf?: JsonSchemaProperty[];
+    anyOf?: JsonSchemaProperty[];
+    oneOf?: JsonSchemaProperty[];
+    not?: JsonSchemaProperty;
+    if?: JsonSchemaProperty;
+    then?: JsonSchemaProperty;
+    else?: JsonSchemaProperty;
+    $defs?: Record<string, JsonSchemaProperty>;
+    definitions?: Record<string, JsonSchemaProperty>;
+    "x-ui-order"?: string[];
+    "x-ui-validate"?: UIValidate;
+    [key: `x-${string}`]: unknown;
+};
+/**
+ * WidthToken -- the shared semantic sizing vocabulary used across the form
+ * layout system: per-field slot width (x-ui-width) and per-column width
+ * (UILayoutRowConfig.widths). "full" fills available space; sm/md/lg are
+ * fixed inline sizes. Raw CSS remains available as an advanced escape hatch.
+ */
+type WidthToken = "sm" | "md" | "lg" | "full";
+/**
+ * The fixed rem values for each non-full WidthToken. This is the single source
+ * of truth for token sizing used by:
+ *  - the CSS grid track map in JsonSchemaFormRenderer (sm -> "8rem" track)
+ *  - the Tailwind class map in FormFieldRenderer (sm -> w-32 = 8rem)
+ * Consumers that need px can multiply by 16.
+ */
+declare const WIDTH_TOKEN_REMS: Record<WidthToken, string>;
+/**
+ * UISchema - User Interface Schema configuration.
+ *
+ * Defines how form fields should be rendered and behave in the UI.
+ * Separate from JSON Schema (which defines data structure) and focuses
+ * on presentation, widgets, and user interaction.
+ */
+interface UISchema {
+    /** Widget name (string) or direct component reference */
+    "x-ui-widget"?: string | object;
+    "x-ui-options"?: UISchemaOptions;
+    "x-ui-globalOptions"?: UISchemaOptions;
+    "x-ui-order"?: string[];
+    /** Declarative show/hide or enable/disable rule (see UIRule). */
+    "x-ui-rule"?: UIRule;
+    /** Custom validators by name (override of the schema-level x-ui-validate). */
+    "x-ui-validate"?: UIValidate;
+    "x-ui-title"?: string | false;
+    "x-ui-description"?: string;
+    "x-ui-placeholder"?: string;
+    /** Semantic field-slot width (default "full"). */
+    "x-ui-width"?: WidthToken;
+    /** Column override -- merged over schema-level x-ui-column, UI schema wins. */
+    "x-ui-column"?: JsonSchemaProperty["x-ui-column"] & {
+        label?: string;
+    };
+    /** Cell renderer override. */
+    "x-ui-cell"?: string;
+    /** Cell renderer options override -- shallow-merged over schema-level x-ui-cell-options. */
+    "x-ui-cell-options"?: Record<string, unknown>;
+    /** Per-field UISchema for nested sub-forms (ObjectWidget / ArrayWidget) */
+    "x-ui-fields"?: {
+        [fieldName: string]: UISchema;
+    };
+    /** Layout config forwarded to the active template (ObjectWidget / ArrayWidget) */
+    "x-ui-layout"?: UILayoutConfig;
+    /** Extension keys not yet enumerated above */
+    [key: `x-ui-${string}`]: unknown;
+}
+/**
+ * UILayoutRowConfig -- one horizontal row in a multi-column object form layout.
+ *
+ * `fields` lists the field names to place in this row, left to right.
+ * Column sizing (grid mode) is resolved in this precedence:
+ *   1. `columns` -- raw CSS grid-template-columns (advanced escape hatch).
+ *   2. `widths`  -- per-cell semantic tokens (the designer-friendly path).
+ *   3. default   -- equal 1fr per field.
+ * `gap` overrides the parent layout gap for this row only.
+ *
+ * `group` renders the row inside a titled fieldset (presentation-only grouping
+ * over flat schema fields -- the data shape is unchanged).
+ *
+ * Examples:
+ *   { fields: ["first_name", "last_name"], widths: ["md", "full"] }
+ *   { fields: ["npi", "specialty", "email"], columns: "20% 1fr 1fr" }
+ *   { group: "Contact", fields: ["email", "phone"] }
+ */
+interface UILayoutRowConfig {
+    fields: string[];
+    columns?: string;
+    /**
+     * Per-cell semantic widths, aligned to `fields` by index. Translated to grid
+     * tracks: sm/md/lg -> fixed rem tracks, full -> 1fr. Ignored when `columns`
+     * is set (raw CSS wins) or in "flow" mode. Missing/short entries default to
+     * "full".
+     */
+    widths?: WidthToken[];
+    gap?: number;
+    /**
+     * Optional title. When set, the row renders inside a <fieldset> with a
+     * <legend>, grouping its fields visually without nesting them in the schema.
+     */
+    group?: string;
+    /**
+     * How this row arranges its fields:
+     *  - "grid" (default): CSS grid using `columns`/`widths` (equal 1fr per field
+     *    when neither is set).
+     *  - "flow": flex row, fields at their natural width, left-to-right, wrapping.
+     *    Use for compact toolbars / tight field groups. `columns`/`widths` are
+     *    ignored.
+     */
+    arrange?: "grid" | "flow";
+}
+/**
+ * One named group of a grouped form layout. A group holds rows of fields under
+ * a label; the data stays flat (grouping is presentation only, like `group` on
+ * a single row). How groups are shown -- tabs, wizard steps, stacked sections
+ * -- is chosen by {@link UILayoutConfig.variant}, not by this structure.
+ *
+ * A group may carry an `x-ui-rule`-style {@link UIRule} to appear conditionally
+ * (e.g. show an "Address" group only when "provide address" is checked). The
+ * rule is evaluated against the form data exactly as a field-level rule is.
+ */
+interface UILayoutGroupConfig {
+    /** Label shown on the group's trigger or heading. */
+    label: string;
+    /** Rows of fields in this group (same shape as UILayoutConfig.rows). */
+    rows: UILayoutRowConfig[];
+    /**
+     * Optional show/hide rule for the whole group: a hidden group disappears
+     * along with its fields. Narrowed to the visibility effects -- a disabled
+     * group has no meaning, and permitting the effect would let it be authored
+     * and then silently ignored.
+     */
+    rule?: UIRule & {
+        effect: "show" | "hide";
+    };
+}
+/**
+ * UILayoutConfig -- layout configuration for ObjectWidget and ArrayWidget.
+ *
+ * Configures the built-in default templates. Has no effect when a custom
+ * template is registered for the field.
+ */
+interface UILayoutConfig {
+    direction?: "vertical" | "horizontal";
+    rows?: UILayoutRowConfig[];
+    groups?: UILayoutGroupConfig[];
+    variant?: "tabs" | "stepper" | "sections" | (string & {});
+    columns?: string;
+    gap?: number;
+    labels?: boolean;
+    compact?: boolean;
+    labelPlacement?: "top" | "start";
+}
+/**
+ * ValueChange -- a single scalar or nested-object field that changed value.
+ *
+ * `path` is a dot-separated field path: "name", "address.city".
+ */
+type ValueChange = {
+    type: "value";
+    path: string;
+    from: unknown;
+    to: unknown;
+};
+/**
+ * ArrayItemChange -- one item-level change within an array field.
+ *
+ * Items are identified by their form-internal `_fid` (never the server ID).
+ * A single item can appear as both "moved" and "modified" if it was
+ * repositioned and its values also changed -- these are emitted as two
+ * separate entries with the same `fid`.
+ */
+type ArrayItemChange = {
+    type: "added";
+    fid: string;
+    index: number;
+    item: unknown;
+} | {
+    type: "removed";
+    fid: string;
+    index: number;
+    item: unknown;
+} | {
+    type: "moved";
+    fid: string;
+    from: number;
+    to: number;
+} | {
+    type: "modified";
+    fid: string;
+    index: number;
+    changes: ValueChange[];
+};
+/**
+ * FieldDiff -- the diff for one top-level form field.
+ */
+type FieldDiff = ValueChange | {
+    type: "array";
+    field: string;
+    changes: ArrayItemChange[];
+};
+/**
+ * FormDiff -- structured diff produced by diffFormData().
+ *
+ * One entry per changed top-level field. Fields whose value is deeply
+ * equal between original and updated are omitted.
+ */
+type FormDiff = FieldDiff[];
+/**
+ * UISchemaOptions - Widget configuration options.
+ */
+interface UISchemaOptions {
+    label?: string | false;
+    disabled?: boolean;
+    readonly?: boolean;
+    compact?: boolean;
+    enumNames?: Record<string | number, string>;
+    inputType?: string;
+    rows?: number;
+    searchable?: boolean;
+    clearable?: boolean;
+    /** Allow the user to type and submit a value not in the enum list (combobox / open-choice). */
+    creatable?: boolean;
+    /** Label placement: "top" (default, above) or "start" (inline, RTL-safe). */
+    labelPlacement?: "top" | "start";
+    /** Semantic field-slot width (default "full"). */
+    width?: WidthToken;
+    [key: string]: any;
+}
+
+export { bindingLists as G, bindingOf as H, codeToken as I, codingKey as K, coreType as L, coreTypeOf as M, parseCodeToken as N, resolveRefs as O, valueTypeResolver as P, QUANTITY_TYPE as Q, WIDTH_TOKEN_REMS as W, CODEABLE_CONCEPT_TYPE as e, CODEABLE_CONCEPT_TYPE_ID as f, CODING_TYPE as g, CODING_TYPE_ID as h, CORE_TYPES_BASE as i, CORE_VALUE_TYPES as j, QUANTITY_TYPE_ID as n, UCUM_SYSTEM as q };
+export type { AdditionalBinding as A, Binding as B, ConceptCoding as C, ValueType as D, WidthToken as E, FormDiff as F, JsonSchemaProperty as J, RefResolver as R, UIRule as U, ValueChange as V, JsonSchema as a, CodeableConcept as b, ArrayItemChange as c, BindingStrength as d, Coding as k, CodingMatch as l, FieldDiff as m, Quantity as o, QuantityComparator as p, UILayoutConfig as r, UILayoutGroupConfig as s, UILayoutRowConfig as t, UIRuleCondition as u, UIRuleEffect as v, UISchema as w, UISchemaOptions as x, UIValidate as y, UIValidateRef as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@petrarca/sonnet-core",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Shared utilities, schema tools, and hooks for the Petrarca Sonnet component library",
   "license": "Apache-2.0",
   "publishConfig": {
@@ -30,26 +30,34 @@
       "import": "./dist/entityOptions/index.js",
       "types": "./dist/entityOptions/index.d.ts"
     },
+    "./terminology": {
+      "types": "./dist/terminology/index.d.ts",
+      "import": "./dist/terminology/index.js"
+    },
     "./config": {
       "import": "./dist/config/index.js",
       "types": "./dist/config/index.d.ts"
+    },
+    "./logger": {
+      "import": "./dist/logger/index.js",
+      "types": "./dist/logger/index.d.ts"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "ajv": "^8.17.1",
+    "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "nanoid": "^5.1.6",
+    "nanoid": "^5.1.16",
     "tailwind-merge": "3.3.1",
-    "zod": "^4.3.6"
+    "zod": "^4.6.7"
   },
   "peerDependencies": {
-    "react": ">=19",
-    "@tanstack/react-query": ">=5"
+    "@tanstack/react-query": ">=5",
+    "react": ">=19"
   },
   "peerDependenciesMeta": {
     "@tanstack/react-query": {
@@ -57,16 +65,16 @@
     }
   },
   "devDependencies": {
-    "@types/react": "^19.0.0",
-    "tsup": "^8.4.0",
-    "typescript": "^5.9.2"
+    "@types/react": "^19.3.0",
+    "tsup": "^9.0.0",
+    "typescript": "^5.9.3"
   },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "vitest run --config ../../vitest.config.ts",
     "clean": "rm -rf dist *.tsbuildinfo"
   }
 }