@comms-id/sanctions 0.2.0 → 0.3.0

package/README.md

@@ -31,3 +31,18 @@ Sanctions screening is not open to a browser holding no credential: call it from
 Entries: `.` (types and errors, safe in a browser), `./server` (signs each call), `./browser` (your relay route; never signs), `./fixtures` (LOCAL FIXTURES, no network), `./descriptor` (what `@comms-id/relay` may forward).
 
 The package is private until the publishing path exists (#515). `LICENSE` is the consumer client licence.
+
+## The form
+
+`@comms-id/sanctions/controller` is the headless controller of a sanctions screening form: values, checks, one explicit submit, the answer, errors and retry, with the accessibility attributes of a labelled form. It has no framework and no DOM. `@comms-id/sanctions-react` (a hook and a component) and `<comms-id-sanctions>` (a web element) run on it, and so can your own UI.
+
+```ts
+import { createSanctionsController } from "@comms-id/sanctions/controller";
+
+const controller = createSanctionsController({ client, onResult: (record, timing) => console.log(record, timing.ms) });
+controller.subscribe(() => render(controller.getState()));
+controller.setValue("name", "…");
+controller.submit();
+```
+
+`src/local/profile.ts` is the only product-specific part: it lists the fields, checks the values, prepares the call and says the reply in plain words. Everything else is generated. Like the client itself, the form is for your server or your relay: screening is never open to a browser that holds no credential.

package/dist/controller.d.ts

@@ -0,0 +1,15 @@
+import type { SanctionsClient } from "./generated/client.js";
+import { type ProductRecord, profile } from "./local/profile.js";
+import type { ScreenController, ScreenControllerOptions, ScreenState } from "./runtime/screen-types.js";
+export type { Attributes, ScreenIds } from "./runtime/screen-aria.js";
+export { fieldId, formAttributes, hintId, inputAttributes, messageId, resultAttributes, statusAttributes, } from "./runtime/screen-aria.js";
+export { initialScreenState } from "./runtime/screen-controller.js";
+export type { Prepared, ResultItem, Run, ScreenError, ScreenField, ScreenProfile, ScreenStatus, Screened, ScreenTiming, ScreenValues, ScreenView, } from "./runtime/screen-types.js";
+export type { SanctionsClient } from "./generated/client.js";
+export { profile };
+export type { ProductRecord as SanctionsRecord };
+export type SanctionsController = ScreenController<ProductRecord>;
+export type SanctionsControllerOptions = Omit<ScreenControllerOptions<SanctionsClient, ProductRecord>, "profile">;
+export type SanctionsState = ScreenState<ProductRecord>;
+/** Creates the controller. Nothing is called until the first `submit`. */
+export declare const createSanctionsController: (options: SanctionsControllerOptions) => SanctionsController;

package/dist/controller.js

@@ -0,0 +1,11 @@
+// Generated by @comms-id/forge-transformers from the service's OpenAPI contract. Do not edit: change the contract and regenerate.
+// Controller entry: the headless controller of the Comms.ID Sanctions screening form, its accessibility
+// attributes and the product's profile. No framework, no DOM. The React package and the web element
+// run on it.
+import { profile } from "./local/profile.js";
+import { createScreenController } from "./runtime/screen-controller.js";
+export { fieldId, formAttributes, hintId, inputAttributes, messageId, resultAttributes, statusAttributes, } from "./runtime/screen-aria.js";
+export { initialScreenState } from "./runtime/screen-controller.js";
+export { profile };
+/** Creates the controller. Nothing is called until the first `submit`. */
+export const createSanctionsController = (options) => createScreenController({ ...options, profile });

package/dist/local/profile.d.ts

@@ -0,0 +1,13 @@
+import type { SanctionsClient } from "../generated/client.js";
+import type { ScreenResponse } from "../generated/types.js";
+import type { ScreenProfile, ScreenView } from "../runtime/screen-types.js";
+/** The reply of the screening: every possible match with its evidence, the list generation and its freshness. */
+export type ProductRecord = ScreenResponse;
+export declare const ATTRIBUTION = "Source: Australian Sanctions Consolidated List, Department of Foreign Affairs and Trade (DFAT).";
+/** True when the text is a real calendar date written YYYY-MM-DD. */
+export declare const isCalendarDate: (text: string) => boolean;
+/** "2026-10-03T00:00:00.000Z" as "2026-10-03 00:00 UTC". */
+export declare const stamp: (iso: string) => string;
+/** The reply in plain words. */
+export declare const describeScreening: (reply: ScreenResponse) => ScreenView;
+export declare const profile: ScreenProfile<SanctionsClient, ProductRecord>;

package/dist/local/profile.js

@@ -0,0 +1,145 @@
+// The Sanctions screening form's profile: the only sanctions-specific code of the form. It checks the
+// values (a name, its kind, and an optional date and place of birth), prepares the call, and reduces
+// the reply to the plain words every UI shows and the record the consumer receives. The controller,
+// the React package and the web element are generated and know nothing else.
+//
+// A result is a list of possible matches with their evidence. "No possible match" is a statement about
+// the exact names and aliases of one generation of the list, and the notes say so; it is never a
+// clearance, and a screening that could not run is an error, never "no possible match".
+export const ATTRIBUTION = "Source: Australian Sanctions Consolidated List, Department of Foreign Affairs and Trade (DFAT).";
+const MAX_TEXT = 1024;
+const DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const GENERATION_SHOWN = 8;
+const KINDS = ["Individual", "Entity", "Vessel"];
+const isKind = (value) => KINDS.includes(value);
+/** True when the text is a real calendar date written YYYY-MM-DD. */
+export const isCalendarDate = (text) => {
+    const match = DATE.exec(text);
+    if (match === null) {
+        return false;
+    }
+    const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+};
+/** "2026-10-03T00:00:00.000Z" as "2026-10-03 00:00 UTC". */
+export const stamp = (iso) => `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC`;
+const range = ([from, to]) => (from === to ? from : `${from} to ${to}`);
+const flagsOf = (candidate) => {
+    const flags = [candidate.nameMatch ? "Name matches" : "Name does not match"];
+    if (candidate.dobMatch !== null) {
+        flags.push(candidate.dobMatch ? "Date of birth matches" : "Date of birth does not match");
+    }
+    if (candidate.pobMatch !== null) {
+        flags.push(candidate.pobMatch ? "Place of birth matches" : "Place of birth does not match");
+    }
+    return flags;
+};
+const itemOf = (candidate, index) => {
+    const { record } = candidate;
+    const lines = [`${record.type} · ${record.nameType} · Reference ${record.reference}`];
+    if (record.dobRanges.length > 0) {
+        lines.push(`Born ${record.dobRanges.map(range).join("; ")}`);
+    }
+    if (record.placeOfBirth.length > 0) {
+        lines.push(`Place of birth: ${record.placeOfBirth.join("; ")}`);
+    }
+    return { key: `${record.reference}-${index}`, title: record.name, lines, flags: flagsOf(candidate) };
+};
+/** The reply in plain words. */
+export const describeScreening = (reply) => {
+    const count = reply.candidates.length;
+    const notes = [
+        `Checked ${stamp(reply.checkedAt)} against list generation ${reply.generation.slice(0, GENERATION_SHOWN)}.`,
+        "Only exact names and aliases are compared: a different spelling is not found.",
+    ];
+    if (reply.freshness.status === "degraded") {
+        notes.push(`The list could not be refreshed on its last attempt. This answer uses the last good list (updated ${stamp(reply.freshness.lastSuccess)}).`);
+    }
+    return {
+        tone: count === 0 ? "clear" : "attention",
+        headline: count === 0
+            ? "No possible match found on the Consolidated List."
+            : `${count} possible match${count === 1 ? "" : "es"} found on the Consolidated List. Review each one.`,
+        items: reply.candidates.map(itemOf),
+        notes,
+    };
+};
+const invalid = (field, message) => ({
+    kind: "invalid",
+    field,
+    message,
+});
+const checked = (values) => {
+    const type = values.type ?? "";
+    const name = (values.name ?? "").trim();
+    const dateOfBirth = (values.dateOfBirth ?? "").trim();
+    const placeOfBirth = (values.placeOfBirth ?? "").trim();
+    if (!isKind(type)) {
+        return invalid("type", "Choose individual, entity or vessel.");
+    }
+    if (name === "") {
+        return invalid("name", "Enter the name to screen.");
+    }
+    if (name.length > MAX_TEXT) {
+        return invalid("name", `The name is too long: at most ${MAX_TEXT} characters.`);
+    }
+    if (dateOfBirth !== "" && !isCalendarDate(dateOfBirth)) {
+        return invalid("dateOfBirth", "Enter the date of birth as YYYY-MM-DD, for example 1970-01-31.");
+    }
+    if (placeOfBirth.length > MAX_TEXT) {
+        return invalid("placeOfBirth", `The place of birth is too long: at most ${MAX_TEXT} characters.`);
+    }
+    return {
+        type,
+        name,
+        ...(dateOfBirth === "" ? {} : { dateOfBirth }),
+        ...(placeOfBirth === "" ? {} : { placeOfBirth }),
+    };
+};
+export const profile = {
+    attribution: ATTRIBUTION,
+    legend: "Sanctions screening",
+    service: "Sanctions screening",
+    submitLabel: "Screen",
+    working: "Screening against the Consolidated List",
+    initial: { type: "Individual", name: "", dateOfBirth: "", placeOfBirth: "" },
+    fields: [
+        {
+            name: "type",
+            label: "Kind",
+            kind: "select",
+            required: true,
+            options: KINDS.map((kind) => ({ value: kind, label: kind })),
+        },
+        { name: "name", label: "Name", kind: "text", required: true, hint: "The full name or an alias." },
+        {
+            name: "dateOfBirth",
+            label: "Date of birth",
+            kind: "date",
+            required: false,
+            placeholder: "YYYY-MM-DD",
+            hint: "For an individual: narrows the possible matches.",
+        },
+        {
+            name: "placeOfBirth",
+            label: "Place of birth",
+            kind: "text",
+            required: false,
+            hint: "For an individual: narrows the possible matches.",
+        },
+    ],
+    prepare: (values) => {
+        const request = checked(values);
+        if ("kind" in request) {
+            return request;
+        }
+        return {
+            kind: "call",
+            run: async (client, options) => {
+                const record = await client.screen(request, options);
+                return { record, view: describeScreening(record), attribution: undefined };
+            },
+        };
+    },
+};

package/dist/runtime/screen-aria.d.ts

@@ -0,0 +1,20 @@
+import type { ScreenField, ScreenState } from "./screen-types.js";
+export interface ScreenIds {
+    readonly form: string;
+    /** Prefix of the field ids; the id of a field is `<prefix>-<name>`. */
+    readonly prefix: string;
+    readonly result: string;
+    readonly status: string;
+}
+/** Attribute name to value; an undefined value means the attribute is left off. */
+export type Attributes = Readonly<Record<string, string | undefined>>;
+export declare const fieldId: (ids: ScreenIds, name: string) => string;
+export declare const hintId: (ids: ScreenIds, name: string) => string;
+export declare const messageId: (ids: ScreenIds, name: string) => string;
+export declare const formAttributes: (state: ScreenState<unknown>, ids: ScreenIds) => Attributes;
+/** The attributes of the input (or select) of one field. */
+export declare const inputAttributes: (state: ScreenState<unknown>, ids: ScreenIds, field: ScreenField) => Attributes;
+/** The polite live region that says what just happened. */
+export declare const statusAttributes: (ids: ScreenIds) => Attributes;
+/** The region that holds the answer: named, so assistive technology can find it. */
+export declare const resultAttributes: (ids: ScreenIds, label: string) => Attributes;

package/dist/runtime/screen-aria.js

@@ -0,0 +1,43 @@
+// Runtime template: copied into a generated client package as src/runtime/screen-aria.ts.
+// The accessibility contract of the screening form, as plain attributes: a labelled form with a
+// fieldset, every input named by its label and tied to its hint and its message, the invalid field
+// marked, and a polite live region for what just happened. The React package and the web element
+// render these attributes unchanged.
+export const fieldId = (ids, name) => `${ids.prefix}-${name}`;
+export const hintId = (ids, name) => `${ids.prefix}-${name}-hint`;
+export const messageId = (ids, name) => `${ids.prefix}-${name}-message`;
+const isInvalid = (state, name) => state.status === "invalid" && state.invalid?.field === name;
+export const formAttributes = (state, ids) => ({
+    id: ids.form,
+    "aria-busy": state.status === "submitting" ? "true" : undefined,
+    novalidate: "",
+});
+/** The attributes of the input (or select) of one field. */
+export const inputAttributes = (state, ids, field) => ({
+    id: fieldId(ids, field.name),
+    name: field.name,
+    "aria-describedby": [
+        field.hint === undefined ? undefined : hintId(ids, field.name),
+        isInvalid(state, field.name) ? messageId(ids, field.name) : undefined,
+    ]
+        .filter((part) => part !== undefined)
+        .join(" ") || undefined,
+    "aria-invalid": isInvalid(state, field.name) ? "true" : undefined,
+    "aria-required": field.required ? "true" : undefined,
+    autocomplete: "off",
+    autocapitalize: "off",
+    spellcheck: "false",
+});
+/** The polite live region that says what just happened. */
+export const statusAttributes = (ids) => ({
+    id: ids.status,
+    role: "status",
+    "aria-live": "polite",
+    "aria-atomic": "true",
+});
+/** The region that holds the answer: named, so assistive technology can find it. */
+export const resultAttributes = (ids, label) => ({
+    id: ids.result,
+    role: "region",
+    "aria-label": label,
+});

package/dist/runtime/screen-controller.d.ts

@@ -0,0 +1,5 @@
+import type { ScreenController, ScreenControllerOptions, ScreenProfile, ScreenState } from "./screen-types.js";
+/** The state of a form nobody has touched. */
+export declare const initialScreenState: <R>(profile: ScreenProfile<never, R>, values?: Readonly<Record<string, string>>) => ScreenState<R>;
+/** Creates the controller. Nothing is called until the first `submit`. */
+export declare const createScreenController: <C, R>(options: ScreenControllerOptions<C, R>) => ScreenController<R>;

package/dist/runtime/screen-controller.js

@@ -0,0 +1,188 @@
+// Runtime template: copied into a generated client package as src/runtime/screen-controller.ts.
+// The headless controller of a screening form: values, checks, one explicit submit, the answer, errors
+// and retry, with no framework and no markup. The React package and the web element both run on it.
+//
+// A screening is never sent while the user types: it is sent when the form is submitted. A change of a
+// value drops the answer that belonged to the old values, so an answer is never shown beside values it
+// is not for. The product-specific part is the profile (src/local/profile.ts).
+import { isCommsIdError, outcomeOf } from "./errors.js";
+const errorMessage = (service, code, outcome) => {
+    if (code === "FAIR_USE_CEILING") {
+        return `The ${service.toLowerCase()} limit is reached. Try again later.`;
+    }
+    if (outcome === "source-unavailable") {
+        return `${service} is unavailable. Try again later.`;
+    }
+    return `${service} failed. Try again.`;
+};
+const toError = (service, cause) => {
+    const outcome = outcomeOf(cause);
+    const base = isCommsIdError(cause)
+        ? { code: cause.code, detail: cause.message, outcome, retryable: cause.retryable, requestId: cause.requestId }
+        : {
+            code: "UNKNOWN",
+            detail: cause instanceof Error ? cause.message : String(cause),
+            outcome,
+            retryable: false,
+            requestId: undefined,
+        };
+    return { ...base, message: errorMessage(service, base.code, outcome) };
+};
+const isOurAbort = (cause) => isCommsIdError(cause) && cause.code === "ABORTED";
+/** The state of a form nobody has touched. */
+export const initialScreenState = (profile, values = {}) => ({
+    values: { ...profile.initial, ...values },
+    status: "idle",
+    invalid: undefined,
+    error: undefined,
+    result: undefined,
+    announcement: "",
+    attribution: profile.attribution,
+});
+/** Creates the controller. Nothing is called until the first `submit`. */
+export const createScreenController = (options) => {
+    const { client, profile } = options;
+    const now = options.now ?? (() => performance.now());
+    const start = options.values ?? {};
+    let state = initialScreenState(profile, start);
+    const listeners = new Set();
+    let sequence = 0;
+    let inFlight;
+    let retryAction;
+    let disposed = false;
+    const notify = () => {
+        for (const listener of [...listeners]) {
+            listener();
+        }
+    };
+    const set = (patch) => {
+        state = { ...state, ...patch };
+        notify();
+    };
+    /** Starts a new generation: a call still in flight becomes stale. */
+    const supersede = () => {
+        sequence += 1;
+        inFlight?.abort();
+        inFlight = undefined;
+        return sequence;
+    };
+    const finish = (screened, started) => {
+        const timing = { ms: Math.round(now() - started) };
+        set({
+            status: "done",
+            error: undefined,
+            invalid: undefined,
+            result: { record: screened.record, view: screened.view, timing },
+            attribution: screened.attribution ?? profile.attribution,
+            announcement: screened.view.headline,
+        });
+        try {
+            options.onResult?.(screened.record, timing);
+        }
+        catch (thrown) {
+            // The consumer's callback must not corrupt the state; surface its error to the page.
+            queueMicrotask(() => {
+                throw thrown;
+            });
+        }
+    };
+    const call = async (generation, run) => {
+        const controller = new AbortController();
+        inFlight = controller;
+        retryAction = () => {
+            const next = supersede();
+            set({ status: "submitting", error: undefined, announcement: `${profile.working}.` });
+            call(next, run).catch(() => undefined);
+        };
+        const started = now();
+        let screened;
+        try {
+            screened = await run(client, { signal: controller.signal });
+        }
+        catch (cause) {
+            if (generation !== sequence || disposed || isOurAbort(cause)) {
+                return;
+            }
+            const error = toError(profile.service, cause);
+            set({ status: "error", error, result: undefined, announcement: error.message });
+            return;
+        }
+        if (generation !== sequence || disposed) {
+            return;
+        }
+        finish(screened, started);
+    };
+    const setValue = (name, value) => {
+        if (disposed || state.values[name] === value) {
+            return;
+        }
+        supersede();
+        set({
+            values: { ...state.values, [name]: value },
+            status: "idle",
+            invalid: undefined,
+            error: undefined,
+            result: undefined,
+            announcement: "",
+            attribution: profile.attribution,
+        });
+    };
+    const submit = () => {
+        if (disposed || state.status === "submitting") {
+            return;
+        }
+        const prepared = profile.prepare(state.values);
+        const generation = supersede();
+        if (prepared.kind === "invalid") {
+            set({
+                status: "invalid",
+                invalid: { field: prepared.field, message: prepared.message },
+                error: undefined,
+                result: undefined,
+                announcement: prepared.message,
+            });
+            return;
+        }
+        set({
+            status: "submitting",
+            invalid: undefined,
+            error: undefined,
+            result: undefined,
+            announcement: `${profile.working}.`,
+        });
+        call(generation, prepared.run).catch(() => undefined);
+    };
+    const reset = () => {
+        if (disposed) {
+            return;
+        }
+        supersede();
+        state = initialScreenState(profile, start);
+        notify();
+    };
+    const retry = () => {
+        if (disposed || state.status !== "error") {
+            return;
+        }
+        retryAction?.();
+    };
+    const dispose = () => {
+        disposed = true;
+        supersede();
+        listeners.clear();
+    };
+    return {
+        getState: () => state,
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setValue,
+        submit,
+        reset,
+        retry,
+        dispose,
+    };
+};

package/dist/runtime/screen-types.d.ts

@@ -0,0 +1,146 @@
+import type { Outcome } from "./errors.js";
+import type { CallOptions } from "./http.js";
+/** A call the profile prepared: it runs against the client when the form is submitted. */
+export type Run<C, T> = (client: C, options: CallOptions) => Promise<T>;
+/** One box of the form. The UIs render the fields in the order the profile lists them. */
+export interface ScreenField {
+    /** Shown under the field, for example the format of a date. */
+    readonly hint?: string;
+    readonly kind: "text" | "select" | "date";
+    readonly label: string;
+    /** The key in the values, and the `name` of the input. */
+    readonly name: string;
+    /** The choices of a select. */
+    readonly options?: readonly {
+        readonly label: string;
+        readonly value: string;
+    }[];
+    readonly placeholder?: string;
+    readonly required: boolean;
+}
+/** What the user typed: one string for each field, empty when nothing was typed. */
+export type ScreenValues = Readonly<Record<string, string>>;
+/** One thing the screening found, as the UIs show it. */
+export interface ResultItem {
+    /** Short statements about how it matched. */
+    readonly flags: readonly string[];
+    /** Unique in one result. */
+    readonly key: string;
+    /** Detail lines under the title. */
+    readonly lines: readonly string[];
+    readonly title: string;
+}
+/** The answer in plain words: what every UI shows, and what assistive technology hears. */
+export interface ScreenView {
+    /** A sentence that says what the screening found. */
+    readonly headline: string;
+    readonly items: readonly ResultItem[];
+    /** Statements that go with the answer, for example how fresh the data is. */
+    readonly notes: readonly string[];
+    /** "attention" when something was found and must be looked at, "clear" when nothing was. */
+    readonly tone: "attention" | "clear";
+}
+export interface Screened<R> {
+    /** The attribution this reply asks for, when it carries one. */
+    readonly attribution: string | undefined;
+    /** What the consumer receives. */
+    readonly record: R;
+    readonly view: ScreenView;
+}
+/** What the profile makes of the values: refuse them, or a call to make. */
+export type Prepared<C, R> = {
+    readonly field: string;
+    readonly kind: "invalid";
+    readonly message: string;
+} | {
+    readonly kind: "call";
+    readonly run: Run<C, Screened<R>>;
+};
+/** The only product-specific part of a screening form: written by hand in the package (src/local/profile.ts). */
+export interface ScreenProfile<C, R> {
+    /** The standard attribution, always shown. */
+    readonly attribution: string;
+    readonly fields: readonly ScreenField[];
+    /** The values of a form nobody has touched. */
+    readonly initial: ScreenValues;
+    /** The visible name of the form (a fieldset legend). */
+    readonly legend: string;
+    /** Checks the values and prepares the call. An invalid value sends nothing. */
+    readonly prepare: (values: ScreenValues) => Prepared<C, R>;
+    /** The service in a failure message: "Sanctions screening" gives "Sanctions screening is unavailable." */
+    readonly service: string;
+    readonly submitLabel: string;
+    /** A phrase for the announcement while the call runs: "Screening the name". */
+    readonly working: string;
+}
+export type ScreenStatus = 
+/** Nothing submitted, or the values changed after the last answer. */
+"idle"
+/** The call is running. */
+ | "submitting"
+/** The answer is in `result`. */
+ | "done"
+/** A value is not valid. Nothing was sent. */
+ | "invalid"
+/** The call failed; `error` says how. */
+ | "error";
+export interface ScreenError {
+    readonly code: string;
+    /** What the technical error said, for a developer: never shown to the end user. */
+    readonly detail: string;
+    readonly message: string;
+    /** A failed call is never shown as "nothing found". */
+    readonly outcome: Outcome;
+    readonly requestId: string | undefined;
+    readonly retryable: boolean;
+}
+export interface ScreenTiming {
+    /** Milliseconds the call took, measured in the browser. */
+    readonly ms: number;
+}
+export interface ScreenState<R> {
+    /** One sentence for assistive technology: what just happened. Empty when nothing needs saying. */
+    readonly announcement: string;
+    /** The attribution to show now: the one the last reply carried, or the standard one. */
+    readonly attribution: string;
+    readonly error: ScreenError | undefined;
+    /** Set with the status "invalid": which field, and why. */
+    readonly invalid: {
+        readonly field: string;
+        readonly message: string;
+    } | undefined;
+    readonly result: {
+        readonly record: R;
+        readonly timing: ScreenTiming;
+        readonly view: ScreenView;
+    } | undefined;
+    readonly status: ScreenStatus;
+    readonly values: ScreenValues;
+}
+export interface ScreenControllerOptions<C, R> {
+    /** Any client of the product's API: server, browser (relay) or fixtures. */
+    readonly client: C;
+    /** Milliseconds, for timing. performance.now by default. */
+    readonly now?: () => number;
+    /** Called once when an answer has arrived, after the state is updated. */
+    readonly onResult?: (record: R, timing: ScreenTiming) => void;
+    readonly profile: ScreenProfile<C, R>;
+    /** Values to start with, for fields the page knows. */
+    readonly values?: ScreenValues;
+}
+export interface ScreenController<R> {
+    /** Stops every call. The controller does nothing afterwards. */
+    dispose: () => void;
+    /** The current state. The same object until the state changes. */
+    getState: () => ScreenState<R>;
+    /** Back to the values the form started with, with no answer and no message. */
+    reset: () => void;
+    /** Runs again the call that failed last. */
+    retry: () => void;
+    /** Changes one value. An answer or message that belonged to the old values is dropped. */
+    setValue: (name: string, value: string) => void;
+    /** Checks the values and, when they are valid, makes the call. */
+    submit: () => void;
+    /** Calls the listener after every change. Returns the function that stops it. */
+    subscribe: (listener: () => void) => () => void;
+}

package/dist/runtime/screen-types.js

@@ -0,0 +1,4 @@
+// Runtime template: copied into a generated client package as src/runtime/screen-types.ts, with
+// screen-controller.ts and screen-aria.ts, when the product has a screening form (generate.config.json,
+// "ui", kind "screen"). The types of the headless screen controller and of the per-product profile.
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comms-id/sanctions",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Typed client for the Comms.ID Sanctions API: screening of one individual, entity or vessel against the Australian Sanctions Consolidated List",
   "type": "module",
   "sideEffects": false,
@@ -19,6 +19,10 @@
       "types": "./dist/browser.d.ts",
       "default": "./dist/browser.js"
     },
+    "./controller": {
+      "types": "./dist/controller.d.ts",
+      "default": "./dist/controller.js"
+    },
     "./fixtures": {
       "types": "./dist/fixtures.d.ts",
       "default": "./dist/fixtures.js"