@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/record/summaryCurrency.d.ts

@@ -0,0 +1,18 @@
+import { DataViewDefinition, SummaryFunction } from '../model/index.js';
+/**
+ * For a summary of money whose currency each record holds, what tells the
+ * currency of its total: the currency field, and the aliases of its distinct
+ * count and one of its values, which the total query asks beside it
+ * (`compileSummaries`). Asked only where the source can answer both — the
+ * analysis capability admits them on that field — else `undefined`, and the
+ * total reads in no currency. A count is in none.
+ */
+export declare function summaryCurrency(definition: DataViewDefinition, summary: {
+    field: string;
+    fn: SummaryFunction;
+}): {
+    field: string;
+    code: string;
+    count: string;
+} | undefined;
+//# sourceMappingURL=summaryCurrency.d.ts.map

package/dist/record/summaryCurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summaryCurrency.d.ts","sourceRoot":"","sources":["../../src/record/summaryCurrency.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACrB,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,eAAe,CAAA;CAAE,GAC9C;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAgB5D"}

package/dist/record/validate.d.ts

@@ -0,0 +1,30 @@
+import { DataViewDefinition, Issue, RecordViewConfig, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+export interface ValidateRecordOptions {
+    limits?: RuntimeLimits;
+}
+/**
+ * Admits a record config against its definition.
+ *
+ * Everything the definition declares is enforced here rather than left to the
+ * backend: a column that no longer exists, a sort on a field that is not
+ * sortable, or a summary the field never offered is a fixable issue, not a
+ * failed query.
+ */
+export declare function validateRecord(definition: DataViewDefinition, config: RecordViewConfig, kinds: FieldKindRegistry, options?: ValidateRecordOptions): Issue[];
+/**
+ * How many fields this definition may be sorted on at once.
+ *
+ * A cursor is a position in one total order and Wow bounds how many fields
+ * that order is built from; a paged query has no such bound, so the answer
+ * is however many fields there are to sort on. The query ends on the row
+ * key (`compileRecord`), which takes one of Wow's slots, so a cursor view
+ * offers one fewer. A definition may lower either (`maxSortFields` on its
+ * record capability), which is where a source's descriptor puts its own
+ * bound. It is exported because a control that offers a field
+ * has to stop where `validateSort` starts refusing — otherwise the pick is
+ * admitted by the UI, refused by the kernel, and the view sits in an error
+ * nobody asked for.
+ */
+export declare function maxSortFields(definition: DataViewDefinition): number;
+//# sourceMappingURL=validate.d.ts.map

package/dist/record/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/record/validate.ts"],"names":[],"mappings":"AAcA,OAAO,EAIL,KAAK,kBAAkB,EAGvB,KAAK,KAAK,EAEV,KAAK,gBAAgB,EACrB,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAOL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,iBAAiB,EACxB,OAAO,GAAE,qBAA0B,GAClC,KAAK,EAAE,CA4CT;AA6FD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAOpE"}

package/dist/routes-DvPNPlQP.js

@@ -0,0 +1,23 @@
+//#region src/runtime/routes.ts
+function e(e, t) {
+	if (e.kind === "url") return e;
+	let n = t(e.definitionId)?.route;
+	return n ? e.kind === "dashboard" ? {
+		kind: "route",
+		path: n(e.instanceId, e),
+		state: {
+			filters: e.filters,
+			...e.tab === void 0 ? {} : { tab: e.tab }
+		},
+		target: e
+	} : {
+		kind: "route",
+		path: n(e.kind === "view" ? e.instanceId : null, e),
+		state: { handOver: e },
+		target: e
+	} : e;
+}
+//#endregion
+export { e as t };
+
+//# sourceMappingURL=routes-DvPNPlQP.js.map

package/dist/routes-DvPNPlQP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-DvPNPlQP.js","names":["DashboardFilters","DashboardTarget","SavedViewTarget","UnsavedViewTarget","ViewHandOver","ViewNavigation","RoutedTarget","ViewRouteState","handOver","filters","tab","boards","Record","ViewRoute","kind","path","state","target","ViewDestination","ViewRouteOf","instanceId","ViewLocation","pathname","search","ViewRouter","location","go","options","replace","resolveNavigation","to","bindingOf","definitionId","route","undefined","resolveNavigation","to","route","bindingOf"],"sources":["../src/runtime/routes.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A way off a board or a view resolved to the host's address\n * (host-integration.md 4): the route a host bound to the definition it\n * leads to, the path and what the page there is handed. Headless — the\n * bindings that hold the routes are React's (`/ui`'s `bind`).\n */\n\nimport type { DashboardFilters } from '../model/index.js';\nimport type {\n  DashboardTarget,\n  SavedViewTarget,\n  UnsavedViewTarget,\n  ViewHandOver,\n  ViewNavigation,\n} from './navigation.js';\n\n/** A way off a board or a view that leads to one of the host's resources. */\nexport type RoutedTarget =\n  SavedViewTarget | UnsavedViewTarget | DashboardTarget;\n\n/** What the page a route opens is handed with it, as history state. */\nexport interface ViewRouteState {\n  /** A view to open as it came (`DataWorkbench`'s `handOver`). */\n  handOver?: ViewHandOver;\n  /** A board's filters (`DashboardWorkbench`'s `initialFilters`). */\n  filters?: DashboardFilters;\n  /** The tab a board opens on (`initialTab`); absent, where it was last read. */\n  tab?: string | null;\n  /**\n   * What each board on the page left its filters and tab at, by the board\n   * (`/ui`'s `ViewHost` writes it as the reader changes them): several\n   * boards on one page each find their own again. A board that wrote\n   * nothing here yet reads `filters` and `tab` above.\n   */\n  boards?: Record<string, { filters?: DashboardFilters; tab?: string | null }>;\n}\n\n/**\n * A way off a board or a view, resolved through its definition's `route`:\n * the host's path, and what the page there is handed.\n */\nexport interface ViewRoute {\n  kind: 'route';\n  path: string;\n  state: ViewRouteState;\n  /** What was asked for, for a host that wants more of it. */\n  target: RoutedTarget;\n}\n\n/**\n * What the host's `navigate` is handed: a route, where the target's\n * definition has one; otherwise the target as it came — a URL, or a\n * definition the host bound no route for.\n */\nexport type ViewDestination = ViewRoute | ViewNavigation;\n\n/**\n * Where a view or a board of a definition lives in the host's address.\n * `target` is the way off it was asked for; it is absent where the engine\n * asks for a link rather than a way off — a resource's or a system view's\n * place in the host's navigation (`useViewNavigation`).\n */\nexport type ViewRouteOf = (\n  instanceId: string | null,\n  target?: RoutedTarget,\n) => string;\n\n/**\n * Where the host's router is (host-integration.md 4.2): what the engine\n * reads the open view (`?view=`), the open record (`?id=`) and what a page\n * was handed (`ViewRouteState`, the history entry's state) from.\n */\nexport interface ViewLocation {\n  /** The path, without its search: `/orders`. */\n  pathname: string;\n  /** The search, with its `?`, or empty. */\n  search: string;\n  /** The state of the history entry, as the router keeps it. */\n  state: unknown;\n}\n\n/**\n * The router port (host-integration.md 4.2): the host's router as the\n * engine reads and moves it — the one bridge to it, whichever library it\n * is. `/react-router`'s `useReactRouter` is one; a host on another router\n * writes these two members over it.\n *\n * The contract is the object's identity: **a new `ViewRouter` object\n * whenever `location` changes, and the same object while it does not.**\n * `ViewHost` hands it down through context, and everything that reads the\n * address — the open view, the open record, a board's filters and tab —\n * re-reads it when, and only when, the object is new. A router mutated in\n * place is never seen to move; one rebuilt on every render reads the\n * address anew on every render. Build it with `useMemo` over the\n * location's parts, as `useReactRouter` does. `go` is read at the moment\n * it is called, so it may be a new function each time.\n */\nexport interface ViewRouter {\n  /** Where the router is now: a new object, in a new router, as it moves. */\n  readonly location: ViewLocation;\n  /**\n   * Goes to `path` — the host's path, its search included — handing the\n   * page there `state` as the history entry's; `replace` replaces the\n   * entry rather than adding one.\n   */\n  go(path: string, options?: { state?: unknown; replace?: boolean }): void;\n}\n\n/**\n * `to` through the route of the definition it leads to, where it has one\n * (`bind`'s `route`, looked up by `bindingOf`): what the host's `navigate`\n * is handed. Pure, and in `/testing` too, so a host's tests of its\n * bindings run the engine's own resolution.\n */\nexport function resolveNavigation(\n  to: ViewNavigation,\n  bindingOf: (definitionId: string) => { route?: ViewRouteOf } | undefined,\n): ViewDestination {\n  if (to.kind === 'url') return to;\n  const route = bindingOf(to.definitionId)?.route;\n  if (!route) return to;\n  if (to.kind === 'dashboard')\n    return {\n      kind: 'route',\n      path: route(to.instanceId, to),\n      state: {\n        filters: to.filters,\n        ...(to.tab !== undefined ? { tab: to.tab } : {}),\n      },\n      target: to,\n    };\n  return {\n    kind: 'route',\n    path: route(to.kind === 'view' ? to.instanceId : null, to),\n    state: { handOver: to },\n    target: to,\n  };\n}\n"],"mappings":";AA+HA,SAAgB6B,EACdC,GACAC,GACiB;CACjB,IAAID,EAAGhB,SAAS,OAAO,OAAOgB;CAC9B,IAAMG,IAAQF,EAAUD,EAAGE,YAAY,CAAC,EAAEC;CAY1C,OAXKA,IACDH,EAAGhB,SAAS,cACP;EACLA,MAAM;EACNC,MAAMkB,EAAMH,EAAGV,YAAYU,CAAE;EAC7Bd,OAAO;GACLP,SAASqB,EAAGrB;GACZ,GAAIqB,EAAGpB,QAAQwB,KAAAA,IAA8B,CAAC,IAAnB,EAAExB,KAAKoB,EAAGpB,IAAI;EAC3C;EACAO,QAAQa;CACV,IACK;EACLhB,MAAM;EACNC,MAAMkB,EAAMH,EAAGhB,SAAS,SAASgB,EAAGV,aAAa,MAAMU,CAAE;EACzDd,OAAO,EAAER,UAAUsB,EAAG;EACtBb,QAAQa;CACV,IAhBmBA;AAiBrB"}

package/dist/runtime/abort.d.ts

@@ -0,0 +1,3 @@
+/** The controller a source takes, following the caller's signal. */
+export declare function abortWith(signal?: AbortSignal): AbortController;
+//# sourceMappingURL=abort.d.ts.map

package/dist/runtime/abort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../../src/runtime/abort.ts"],"names":[],"mappings":"AAaA,oEAAoE;AACpE,wBAAgB,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,eAAe,CAQ/D"}

package/dist/runtime/actions.d.ts

@@ -0,0 +1,241 @@
+import { FieldOption, RecordKey } from '../model/index.js';
+import { RecordRow } from '../record/index.js';
+/**
+ * Declared actions (host-integration.md 5, D67): the host says **what** —
+ * which commands a record takes, when, what a refusal says, whether to ask
+ * first and what to ask for — and the engine decides **where and how**:
+ * the row's inline button and its overflow menu, the selection's bar, the
+ * record detail, the confirmation and the form, a selection partly able to
+ * take a command, the run a few at a time with its progress, its stop and
+ * its outcome, and the refresh after.
+ *
+ * Everything here is headless: the declarations, and the pure reading of
+ * them the UI and `/testing`'s `actionHarness` share, so a host's unit test
+ * asks the very rules the screen draws by.
+ */
+/** A record as an action is handed it: its key and its data. */
+export type ActionRow = RecordRow;
+/** Where a declared action is offered. */
+export type ActionPlace = 'row' | 'bulk' | 'detail';
+/** Every place, in order: what an action that names none is offered at. */
+export declare const ACTION_PLACES: readonly ActionPlace[];
+/** How much an action costs: `danger` draws it (and its confirmation) red. */
+export type ActionTone = 'default' | 'danger';
+/** What a form (or a choice) gave, by field name. */
+export type ActionInput = Readonly<Record<string, unknown>>;
+/**
+ * What an action's rules are asked with: the time they are asked at — the
+ * engine's clock, a harness's own in a test — and, where one is known, the
+ * input the command would run with (a choice's option, a filled form).
+ */
+export interface ActionContext {
+    readonly now: number;
+    readonly input?: ActionInput;
+}
+/** `true`, or why not — a key (`text(…)`) or words, said where shown. */
+export type Availability = true | string;
+/**
+ * One field of an action's form, drawn by the condition editor's own value
+ * controls (`FilterValueEditor`): a list of options, a number, a yes/no or
+ * a line of text.
+ */
+export interface ActionFormField {
+    label: string;
+    /** Options to pick one of; the field is then a choice. */
+    options?: readonly FieldOption[];
+    /** Without options: what is typed. `text` by default. */
+    input?: 'text' | 'number' | 'boolean';
+    /** Whether the command can run without it; `true` by default. */
+    required?: boolean;
+    /** What the form opens with. */
+    initial?: string | number | boolean;
+}
+/** An action's form, by field name: what `run` receives as its input. */
+export type ActionForm = Readonly<Record<string, ActionFormField>>;
+/**
+ * The question an action asks before it runs. Words are keys or text;
+ * `{count}` is how many records it is for (with a `-one` form where a
+ * language says one apart), `{value}` the option a choice picked.
+ */
+export interface ActionConfirm {
+    title: string;
+    body?: string;
+    /**
+     * The confirming button, and the run's name on the outcome line; the
+     * action's label by default.
+     */
+    action?: string;
+    /** The action's tone by default. */
+    tone?: ActionTone;
+    /**
+     * `always` (the default): one record asks too. `bulk`: only a selection
+     * asks — a command safe for one record that the reader should count
+     * before it goes to many. A selection always asks either way.
+     */
+    ask?: 'always' | 'bulk';
+}
+/** One declared command on a record. */
+export interface RecordAction {
+    /** Unique among the actions of one binding. */
+    readonly id: string;
+    readonly label: string;
+    /** The one a reader presses most: a button in the row, not in the menu. */
+    readonly primary?: boolean;
+    readonly tone?: ActionTone;
+    /** Where it is offered; every place by default. */
+    readonly on?: readonly ActionPlace[];
+    /**
+     * Whether this record does not show the action at all — the reader may
+     * not do it — as against `available`, which shows it disabled with why.
+     */
+    hidden?(row: RecordRow, context: ActionContext): boolean;
+    /**
+     * `true` when the record takes the command now, else why not. Asked with
+     * the input where one is known, so a choice can refuse one option (the
+     * value the record already holds) and offer the rest.
+     */
+    available?(row: RecordRow, context: ActionContext): Availability;
+    /**
+     * When `available` next changes on its own — a prepared execution becomes
+     * preparable once it times out — as a time in milliseconds; nothing when
+     * only a new state changes it. The engine asks again then, so the host
+     * keeps no timer.
+     */
+    changesAt?(row: RecordRow, context: ActionContext): number | null | undefined;
+    /**
+     * Ask first; a function of the input, where the words depend on it. Its
+     * words are said with `{count}` (how many records), `{value}` (a choice's
+     * option) and `{record}` (the record's key, when it is one record).
+     */
+    readonly confirm?: ActionConfirm | ((input: ActionInput) => ActionConfirm);
+    /**
+     * What the command needs besides the record. A form of one field with
+     * options is a choice: its options are offered in the menu, and the one
+     * picked is the input.
+     */
+    readonly form?: ActionForm;
+    /**
+     * Sends the command for one record. It resolves once the read model
+     * reflects it — a Wow command waits for `CommandStage.SNAPSHOT` (or the
+     * stage the host's projection needs) — because the engine reads the view
+     * again right after, and a refresh that ran ahead of the command would
+     * show the old state. It throws when the command was refused; what it
+     * throws is read for the source's own reason.
+     *
+     * A command is a write, so make it idempotent — a request id or an
+     * idempotency key the service deduplicates by: a `run` that times out or
+     * loses the network after sending has an outcome nobody knows, and the
+     * reader, told to check, may press again.
+     */
+    run(row: RecordRow, input: ActionInput): Promise<unknown>;
+    /**
+     * How long one record's `run` is waited for, in milliseconds. Past it the
+     * engine stops waiting and reports the record's outcome as unknown — it
+     * may have taken the command — rather than holding the surface busy.
+     * No deadline by default.
+     */
+    readonly timeout?: number;
+}
+/** A binding's declared actions, as `actions()` hands them back. */
+export type RecordActions = readonly RecordAction[];
+/**
+ * A binding's actions, checked: every one has an id no other has, a label
+ * and a `run`. A mistake here is the host's code, so it throws at once.
+ */
+export declare function actions(list: readonly RecordAction[]): RecordActions;
+/** The actions offered at `place`, in the order declared. */
+export declare function offeredAt(list: RecordActions | undefined, place: ActionPlace): RecordAction[];
+/** Why a record the engine does not hold is not sent: it is not on screen. */
+export declare const UNSEEN: import('../index.js').Text;
+/** Why a record the action is hidden on is not sent. */
+export declare const NOT_OFFERED: import('../index.js').Text;
+/** What a refusal without words of the host's own says. */
+export declare const UNAVAILABLE: import('../index.js').Text;
+/** What a failure whose error carries no words says. */
+export declare const FAILED: import('../index.js').Text;
+/** Why a record's outcome is unknown: its `run` outlasted the action's `timeout`. */
+export declare const TIMED_OUT: import('../index.js').Text;
+/** Why a record's outcome is unknown: the reader stopped waiting for it. */
+export declare const ABANDONED: import('../index.js').Text;
+/** One action on one record: hidden, or available, or refused and why. */
+export interface ActionState {
+    hidden: boolean;
+    available: boolean;
+    /** Why not, as the host said it; `null` while it is available. */
+    reason: string | null;
+}
+/**
+ * What one action says about one record now. A rule that throws is the
+ * host's bug, and it refuses rather than offering a command nobody checked.
+ */
+export declare function actionState(action: RecordAction, row: RecordRow, context: ActionContext): ActionState;
+/** A form that is one field of options: offered as its options. */
+export interface ActionChoice {
+    name: string;
+    field: ActionFormField;
+    options: readonly FieldOption[];
+}
+/** The choice an action's form is, or `null` for a form to fill (or none). */
+export declare function choiceOf(action: RecordAction): ActionChoice | null;
+/** What a form opens with: each field's `initial`, where it has one. */
+export declare function initialInput(action: RecordAction): ActionInput;
+/** The required fields `input` leaves blank, by name, in the form's order. */
+export declare function missingInput(action: RecordAction, input: ActionInput): string[];
+/**
+ * The question an action asks with this input, or `null`. A question the
+ * host computes and that throws is the host's bug: the action is asked by
+ * its name rather than sent unasked or taking the surface down.
+ */
+export declare function confirmOf(action: RecordAction, input: ActionInput): ActionConfirm | null;
+/**
+ * Whether pressing the action at `place` opens a dialog before anything is
+ * sent: a selection always does (how many, and which will not take it), a
+ * form to fill does, and a record's own press does where the action asks
+ * first. A choice's option is its input, so a choice alone asks nothing.
+ */
+export declare function asksFirst(action: RecordAction, place: ActionPlace, input: ActionInput): boolean;
+/** One record the command will not be sent to, and why. */
+export interface ActionRefusal {
+    key: RecordKey;
+    reason: string;
+}
+/** A selection split by what one action says of each record. */
+export interface ActionSplit {
+    /** The records that take it, in the order given. */
+    able: RecordKey[];
+    refused: ActionRefusal[];
+}
+/**
+ * `keys` split by whether each takes the action now — a record the engine
+ * does not hold is refused (`UNSEEN`), since its state is not known and
+ * `run` is handed the record.
+ */
+export declare function splitFor(action: RecordAction, keys: readonly RecordKey[], rowOf: (key: RecordKey) => RecordRow | undefined, context: ActionContext): ActionSplit;
+/** The refused, by reason, the commonest first; ties keep their order. */
+export interface RefusalGroup {
+    reason: string;
+    keys: RecordKey[];
+}
+export declare function refusalsByReason(refused: readonly ActionRefusal[]): RefusalGroup[];
+/**
+ * The soonest time after `now` any of `rows` changes its availability on
+ * its own (`changesAt`), or `null` when none will.
+ */
+export declare function nextChange(list: RecordActions | undefined, rows: readonly RecordRow[], now: number): number | null;
+/**
+ * A record the engine did not send the command to, because the action
+ * refused it when it came to its turn. It carries the reason as the host
+ * gave it (a key stays a key), where a thrown error is read for the
+ * source's words.
+ */
+export declare class ActionRefusedError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+/**
+ * Sends one record the command as the engine does: asked again at the
+ * moment it goes (the state may have changed since it was picked), and
+ * refused with the reason rather than sent where it no longer takes it.
+ */
+export declare function runOne(action: RecordAction, row: RecordRow | undefined, input: ActionInput, now: number): Promise<unknown>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/runtime/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/runtime/actions.ts"],"names":[],"mappings":"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"}

package/dist/runtime/admission.d.ts

@@ -0,0 +1,35 @@
+import { QueryModelDescriptor } from '@ahoo-wang/wow-client';
+import { Issue, RuntimeLimits, ViewDefinition } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+/**
+ * What `admit` takes one of: a definition, or a resource holding one — the
+ * shape a host registers (host-integration.md 4), so a host's list of
+ * resources is passed as it is.
+ */
+export type Admissible = ViewDefinition | {
+    definition: ViewDefinition;
+};
+export interface AdmitOptions {
+    /** The words the definitions' keys are said in (`ViewEngineOptions.text`). */
+    text?(key: string): string | undefined;
+    kinds?: FieldKindRegistry;
+    limits?: Partial<RuntimeLimits>;
+}
+/** One finding, with the definition it is about. */
+export type AdmitFinding = Issue & {
+    definition: string;
+};
+/**
+ * Every finding the engine would have about `definitions` over
+ * `descriptors` (the snapshots, by `DataViewDefinition.source`), each with
+ * the definition it is about; `[]` for a host's declarations that hold.
+ *
+ * Each definition is admitted as the engine admits it when registered —
+ * its keys said in `text`, its own rules, its boards against every other
+ * definition (C) — and each data definition narrowed to its descriptor as
+ * a source would narrow it (N5), what that takes away said too. A
+ * definition over a source with no descriptor given is said to be, since
+ * its capabilities go unchecked.
+ */
+export declare function admit(definitions: readonly Admissible[], descriptors: Readonly<Record<string, QueryModelDescriptor>>, options?: AdmitOptions): AdmitFinding[];
+//# sourceMappingURL=admission.d.ts.map

package/dist/runtime/admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission.d.ts","sourceRoot":"","sources":["../../src/runtime/admission.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAEL,KAAK,KAAK,EACV,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAK5B;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG;IAAE,UAAU,EAAE,cAAc,CAAA;CAAE,CAAC;AAEzE,MAAM,WAAW,YAAY;IAC3B,8EAA8E;IAC9E,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACvC,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CACjC;AAED,oDAAoD;AACpD,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CACnB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,EAC3D,OAAO,GAAE,YAAiB,GACzB,YAAY,EAAE,CA6ChB"}

package/dist/runtime/autoApply.d.ts

@@ -0,0 +1,51 @@
+import { Issue, ViewConfig } from '../model/index.js';
+/**
+ * 「改了就跑」 (D20; todo 批 7): a question that changed runs again on its
+ * own, a moment after the last edit, so the analyst reads the answer rather
+ * than pressing for it. Which members are the question is the model's to
+ * say, beside the types they are members of (`autoRunMembers`): a kind with
+ * none declared never runs on its own, and the runtime carries no rule of
+ * any one kind. Three things hold a draft back:
+ *
+ * - the draft is refused — a question that cannot run is not run;
+ * - a member outside the question changed — the **range** above all, whose
+ *   conditions still wait for Apply (D20); and while they wait nothing else
+ *   runs either, because Apply runs the whole draft and a half-applied draft
+ *   would say two things at once;
+ * - the view has it switched off (`ViewPreferences.autoRun`), in which case
+ *   Apply is the one way to run.
+ *
+ * The delay merges a burst of edits — a dimension added and its granularity
+ * changed — into one query.
+ */
+export declare const AUTO_APPLY_DELAY_MS = 300;
+export interface AutoApplyState {
+    draft: ViewConfig;
+    applied: ViewConfig;
+    issues: readonly Issue[];
+    autoApply: boolean;
+}
+/** Whether the draft is one the runtime should run on its own now. */
+export declare function autoApplyDue(state: AutoApplyState): boolean;
+/**
+ * Whether the rows on screen answer an older question than the one on its
+ * way: a query is in flight and what it asks differs from what the result
+ * answered, in a member that does more than draw it.
+ *
+ * The other half of a result that is out of date. `autoApplyDue` covers the
+ * moment before the question is sent — the debounce — and went false the
+ * moment it was, so a slow answer left the old rows standing at full
+ * strength as though they were the new ones (2026-09-23 audit). A refresh of
+ * the same question is not this: its rows are the answer to what is being
+ * asked, and they stay as they are until the new ones land.
+ */
+export declare function answeringAnew(state: {
+    applied: ViewConfig;
+    query: {
+        status: string;
+    };
+    result: {
+        own: ViewConfig;
+    } | null;
+}): boolean;
+//# sourceMappingURL=autoApply.d.ts.map

package/dist/runtime/autoApply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoApply.d.ts","sourceRoot":"","sources":["../../src/runtime/autoApply.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,KAAK,EACV,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAG3B;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAM3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,OAAO,EAAE,UAAU,CAAC;IACpB,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B,MAAM,EAAE;QAAE,GAAG,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI,CAAC;CACpC,GAAG,OAAO,CAGV"}

package/dist/runtime/capabilities.d.ts

@@ -0,0 +1,98 @@
+import { DataViewDefinition, Issue, RuntimeLimits, ViewDefinition, ViewInstance } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { RuntimeEnvironment } from './environment.js';
+import { ViewSource } from './source.js';
+/** What the capabilities read from the engine that owns them. */
+export interface CapabilityHost {
+    readonly kinds: FieldKindRegistry;
+    /** The host's own limits, as it gave them; the source budgets may be left out. */
+    readonly limits: Partial<RuntimeLimits> | undefined;
+    readonly environment: RuntimeEnvironment;
+    resolveSource(key: string): ViewSource;
+    /** A definition as the application declared it, by id. */
+    declared(id: string): ViewDefinition | undefined;
+    /** A finding with nobody to reject: `onIssue`. */
+    report(found: Issue): void;
+}
+/** A definition and the limits a runtime over it runs under. */
+export interface EffectiveDefinition {
+    definition: DataViewDefinition;
+    limits: RuntimeLimits;
+}
+export declare class SourceCapabilities {
+    /**
+     * The limits of a source with no descriptor: the host's over the
+     * defaults, as every source ran under before descriptors.
+     */
+    readonly fallback: RuntimeLimits;
+    private readonly host;
+    private readonly cache;
+    /** Each definition narrowed to the version it was narrowed against. */
+    private readonly narrowed;
+    private readonly limitsBySource;
+    private readonly stopWatching;
+    /** Who runs on each source, told when its descriptor changes. */
+    private readonly watchers;
+    constructor(host: CapabilityHost);
+    /**
+     * Reads the descriptor of every source the instance's view runs on, the
+     * first time a view over it opens, so its first query already goes out
+     * narrowed; later openings answer at once and check a stale descriptor
+     * in the background. A board's saved views are read as each panel
+     * resolves (`prepare`); the views it owns are read here.
+     */
+    prepareFor(instance: ViewInstance): Promise<void>;
+    /**
+     * Reads one definition's source descriptor; see `prepareFor`. Waited for
+     * no longer than `DESCRIBE_DEADLINE_MS`: past it the view opens on the
+     * definition as declared, as it does when the read fails, and the read
+     * still in flight narrows it when it lands (`changed`).
+     */
+    prepare(definition: ViewDefinition): Promise<void>;
+    /**
+     * Starts reading a source's descriptor without waiting, for a view made
+     * from nothing (`create`), which cannot wait: it runs on what is held,
+     * and the next view over the source on what this read brings.
+     */
+    warm(definition: ViewDefinition): void;
+    /**
+     * Tells `listener` whenever the descriptor of `source` is first read or
+     * changes version. Returns the way to stop.
+     */
+    watch(source: string, listener: () => void): () => void;
+    /** Checks a source's descriptor again when it is stale: a press of refresh. */
+    revalidate(source: string): void;
+    /**
+     * Checks a source's descriptor again at once, because the source refused
+     * a query for a capability the descriptor admitted (capabilities.md 7,
+     * C5). A new version narrows every view over the source through `watch`;
+     * the same version means the descriptor and the service's admission
+     * disagree — the service's defect — and it is told to `onIssue` as an
+     * error, beside the rejection the view already says. Resolves whether the
+     * version changed.
+     */
+    recheck(source: string, code: string | undefined): Promise<boolean>;
+    /**
+     * The definition a runtime over it runs on, and the limits: narrowed to
+     * the descriptor held for its source, or as declared while there is
+     * none. Refused, as a definition failing admission is, when the
+     * descriptor contradicts it (capabilities.md 4.6).
+     */
+    effective(definition: DataViewDefinition): EffectiveDefinition;
+    dispose(): void;
+    /**
+     * How to read a source's descriptor, or `null` without one. A key the
+     * host cannot resolve is left to fail where it always has — when a view
+     * over it is built — so a board's other panels are not taken down with it.
+     */
+    private describer;
+    /**
+     * Narrowed once per descriptor version, and what it found reported once
+     * with it (capabilities.md 4.6). The definition narrowed is the declared
+     * one, whatever copy the caller holds — a panel's may already be
+     * narrowed against an older version.
+     */
+    private narrow;
+    private limitsOf;
+}
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/runtime/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/runtime/capabilities.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,kBAAkB,EAClB,KAAK,EACL,aAAa,EACb,cAAc,EACd,YAAY,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAS,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAUnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IACvC,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IACjD,kDAAkD;IAClD,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC5B;AAED,gEAAgE;AAChE,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAiB;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAGrB;IACJ,OAAO,CAAC,QAAQ,CAAC,cAAc,CAG3B;IACJ,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAa;IAC1C,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;gBAEnD,IAAI,EAAE,cAAc;IA4BhC;;;;;;OAMG;IACG,UAAU,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAavD;;;;;OAKG;IACG,OAAO,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBxD;;;;OAIG;IACH,IAAI,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IAItC;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAYvD,+EAA+E;IAC/E,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIhC;;;;;;;;OAQG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBzE;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,kBAAkB,GAAG,mBAAmB;IAsB9D,OAAO,IAAI,IAAI;IAIf;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAWjB;;;;;OAKG;IACH,OAAO,CAAC,MAAM;IAmBd,OAAO,CAAC,QAAQ;CAUjB"}

package/dist/runtime/commandChecks.d.ts

@@ -0,0 +1,22 @@
+import { Issue, ViewConfig } from '../model/index.js';
+import { ManagedViewRuntime } from './viewRuntimeTypes.js';
+/**
+ * A view needs a title, and the store keeps one of at most
+ * `MAX_VIEW_TITLE_LENGTH` (`view.title.empty`, `view.title.too-long`): the
+ * engine refuses it here rather than send what the store refuses. Answers
+ * the title as it is stored, trimmed.
+ */
+export declare function requireTitle(title: string): string;
+/**
+ * The draft as a runtime writes it to the store (`stored`, where its kind
+ * stores less than it reads), refused when the store would not keep it.
+ */
+export declare function storable(runtime: ManagedViewRuntime, draft: ViewConfig): ViewConfig;
+/**
+ * A config the store keeps: at most `MAX_VIEW_CONFIG_BYTES` of JSON
+ * (`view.config.too-large`). A board of many panels is what reaches it.
+ */
+export declare function requireStorable<C extends ViewConfig>(config: C): C;
+/** What stops a save of this runtime's kind (`stopsSave`). */
+export declare function requireSavable(runtime: ManagedViewRuntime, issues: readonly Issue[]): void;
+//# sourceMappingURL=commandChecks.d.ts.map

package/dist/runtime/commandChecks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandChecks.d.ts","sourceRoot":"","sources":["../../src/runtime/commandChecks.ts"],"names":[],"mappings":"AAaA;;;GAGG;AAEH,OAAO,EAKL,KAAK,KAAK,EACV,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGhE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWlD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,UAAU,GAChB,UAAU,CAEZ;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAUlE;AAED,8DAA8D;AAC9D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,IAAI,CAGN"}

package/dist/runtime/dashboard/anchor.d.ts

@@ -0,0 +1,46 @@
+import { DashboardFilters, DashboardViewConfig, DataViewConfig, FilterLeaf, PanelBinding } from '../../model/index.js';
+/** The moment and the zone a relative date is read at. */
+export interface AnchorClock {
+    now: Date;
+    timeZone: string;
+}
+/**
+ * A trend card anchored to the day a board's date filter picked (D39): the
+ * config its child runs — its own relative dates read as of that day — and,
+ * in place of the filter's own condition, the window that ends with it.
+ */
+export interface PanelAnchor {
+    /** The binding whose condition the window stands in for. */
+    binding: PanelBinding;
+    /** The card's config, its own relative dates on the axis read at the anchor. */
+    config: DataViewConfig;
+    /** The window, on the panel's own field: `BETWEEN` two instants. */
+    leaf: FilterLeaf;
+}
+/**
+ * Where a trend card on a board ends its window (D39).
+ *
+ * A board's date filter narrows each panel wired to it. Narrowed to one
+ * day, a card that reads 「较前一日」 and draws the last 30 days has one
+ * bucket: nothing to compare with, no line. So a metric card with a trend
+ * read as its last period (`MetricTrend.headline` `last`), whose time axis
+ * is wired to a date filter holding exactly one period of the axis's unit
+ * — 「昨日」 on a card by the day, 「上月」 on one by the month, as
+ * `periodOf` reads it — is anchored to that period instead: its window
+ * ends with it, and the headline is it, compared with the one before.
+ *
+ * How far back the window reaches is the card's own to say, the way it says
+ * it anywhere else: a condition of its own on that field (「近 30 天」),
+ * read as of the anchored period's last moment, so 「近 30 天」 on a board
+ * set to 9 月 21 日 is 8 月 23 日 to 9 月 21 日. A card with no condition of
+ * its own on the field reaches back one period, which is what 「较前一日」
+ * needs. Every other panel wired to the filter is narrowed as before.
+ *
+ * `null` when the panel is not such a card, when no date filter wired to
+ * its axis holds a value, when two do, or when the value is no one period.
+ */
+export declare function panelAnchor(config: DataViewConfig, bindings: readonly PanelBinding[], board: {
+    applied: DashboardViewConfig;
+    filters: DashboardFilters;
+}, clock: AnchorClock): PanelAnchor | null;
+//# sourceMappingURL=anchor.d.ts.map

package/dist/runtime/dashboard/anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.d.ts","sourceRoot":"","sources":["../../../src/runtime/dashboard/anchor.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,UAAU,EAGf,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAa9B,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,IAAI,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,OAAO,EAAE,YAAY,CAAC;IACtB,gFAAgF;IAChF,MAAM,EAAE,cAAc,CAAC;IACvB,oEAAoE;IACpE,IAAI,EAAE,UAAU,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,KAAK,EAAE;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,gBAAgB,CAAA;CAAE,EAClE,KAAK,EAAE,WAAW,GACjB,WAAW,GAAG,IAAI,CAgDpB"}