@iyulab/lowline-form 0.4.0 → 0.6.0

package/dist/client.d.ts

@@ -5,9 +5,46 @@ export declare class LowlineError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
 }
+/** A threshold chosen on a replay of the settled records, and what the replay saw at it. */
+export interface ThresholdChoice {
+    threshold: number;
+    /** The share of the replay's answers at this threshold that were right. */
+    precision: number;
+    /** The share of lookups answered at it. */
+    answer_rate: number;
+    answered: number;
+    lookups: number;
+    /** The precision over the latest records (`promiseOver` of them), on `promise_answered` independent answers. */
+    promise: number;
+    promise_answered: number;
+}
+/**
+ * How one decided field's replays went when its thresholds were chosen — `GET {src}/{form}/report`. A part with
+ * nothing to say is left out.
+ */
+export interface FieldReport {
+    field: string;
+    lookups: number;
+    /** The threshold at which values settled alongside answer; absent while none was right often enough. */
+    key?: ThresholdChoice;
+    /** When `key` is absent, the closest the replay came; absent when too few were answered to say. */
+    closest?: ThresholdChoice;
+    /** The fields chosen to key it; absent when every field it rests on does. */
+    keyFields?: string[];
+    /** For a free text field, the threshold for one, two, … characters typed (`null` where none was right often enough). */
+    typed?: (ThresholdChoice | null)[];
+    coarse?: ThresholdChoice;
+    similar?: ThresholdChoice;
+    similarOffered: boolean;
+    promiseOver: number;
+    /** How many checks — answers held back while a person wrote the value — are among the records. */
+    checks: number;
+    /** What the precision was counted on: values settled with nothing in view and checks, or every settled value. */
+    counting: 'unprompted' | 'settled';
+}
 /**
  * The routes a Lowline host maps (`MapLowline` in .NET): `POST {src}/{form}/propose` and `POST {src}/{form}/settle`,
- * and — when the host gave a model — `fill` and `judge`. The host decides the memory space and the choices a person may pick from the request
+ * `GET {src}/{form}/report`, and — when the host gave a model — `fill` and `judge`. The host decides the memory space and the choices a person may pick from the request
  * itself — its sign-in — so the calls carry the record only.
  */
 export declare class LowlineClient {
@@ -31,5 +68,8 @@ export declare class LowlineClient {
      * (`needs-judgement`) — 404 when the host gave no model.
      */
     judge(form: string, id: string, values: Values): Promise<Proposal[]>;
+    /** Per decided field, in the form's order, the thresholds chosen on this memory space's records and what the replay saw. */
+    report(form: string): Promise<FieldReport[]>;
     private post;
+    private send;
 }

package/dist/client.js

@@ -8,7 +8,7 @@ export class LowlineError extends Error {
 }
 /**
  * The routes a Lowline host maps (`MapLowline` in .NET): `POST {src}/{form}/propose` and `POST {src}/{form}/settle`,
- * and — when the host gave a model — `fill` and `judge`. The host decides the memory space and the choices a person may pick from the request
+ * `GET {src}/{form}/report`, and — when the host gave a model — `fill` and `judge`. The host decides the memory space and the choices a person may pick from the request
  * itself — its sign-in — so the calls carry the record only.
  */
 export class LowlineClient {
@@ -38,14 +38,21 @@ export class LowlineClient {
     judge(form, id, values) {
         return this.post(form, 'judge', { id, values });
     }
-    async post(form, route, body) {
-        const url = `${this.src.replace(/\/+$/, '')}/${encodeURIComponent(form)}/${route}`;
-        const response = await this.fetcher(url, {
+    /** Per decided field, in the form's order, the thresholds chosen on this memory space's records and what the replay saw. */
+    report(form) {
+        return this.send(form, 'report', { method: 'GET', credentials: 'same-origin' });
+    }
+    post(form, route, body) {
+        return this.send(form, route, {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
             body: JSON.stringify(body),
             credentials: 'same-origin',
         });
+    }
+    async send(form, route, init) {
+        const url = `${this.src.replace(/\/+$/, '')}/${encodeURIComponent(form)}/${route}`;
+        const response = await this.fetcher(url, init);
         if (!response.ok) {
             const problem = await response.json().catch(() => undefined);
             throw new LowlineError(response.status, problem?.detail ?? `${route} answered ${response.status}`);

package/dist/headless.d.ts

@@ -1,3 +1,3 @@
 export { Draft, valuesOf, type Suggestion, type Value, type Values } from './draft.js';
 export { Session, englishStrings, type Abstain, type Basis, type FieldState, type Proposal, type Round, type Strings } from './session.js';
-export { LowlineClient, LowlineError } from './client.js';
+export { LowlineClient, LowlineError, type FieldReport, type ThresholdChoice } from './client.js';

package/dist/session.d.ts

@@ -10,7 +10,7 @@ export type Basis = {
     similarity: number;
 };
 /** Why a decided field is shown no suggestion. */
-export type Abstain = 'off' | 'no-evidence' | 'unsure' | 'not-allowed' | 'needs-judgement' | 'not-a-choice' | 'malformed';
+export type Abstain = 'off' | 'no-evidence' | 'unsure' | 'not-allowed' | 'needs-judgement' | 'not-a-choice' | 'malformed' | 'together';
 /** What the host's engine says to show for one decided field. */
 export interface Proposal {
     field: string;
@@ -21,6 +21,14 @@ export interface Proposal {
     basis?: Basis[];
     abstain: Abstain | null;
     asks?: [string, string][];
+    /** For `together`: the fields of its group, still open, that are shown no suggestion. */
+    with?: string[];
+    /**
+     * How often an answer of this kind for this field has been right — the replay's precision at the threshold the
+     * suggestion was held to. Absent with no suggestion, for a judgement or a value from elsewhere, and before thresholds
+     * were chosen.
+     */
+    promise?: number;
 }
 /** What a field shows, as formdown's `fieldStates` takes it. */
 export interface FieldState {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iyulab/lowline-form",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "The Lowline form element: a formdown form whose decided fields are suggested from the records people confirmed, talking to a Lowline host's routes.",
   "license": "MIT",
   "repository": {
@@ -40,7 +40,7 @@
     "bundle": "vite build --config vite.bundle.config.ts"
   },
   "dependencies": {
-    "@formdown/ui": "^0.24.0",
+    "@formdown/ui": "^0.25.0",
     "lit": "^3.3.3"
   },
   "devDependencies": {