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

package/dist/runtime/resources.d.ts

@@ -0,0 +1,73 @@
+import { Issue, TextResolver, ViewDefinition } from '../model/index.js';
+import { OptionSource, ViewSource } from './source.js';
+/** What the engine's resources are read from; see `ViewEngineOptions`. */
+export interface ResourceHost {
+    resources: readonly {
+        definition: ViewDefinition;
+        source?: ViewSource;
+    }[];
+    resolveOptions?(key: string): OptionSource;
+    text?(key: string): string | undefined;
+    onIssue?(issue: Issue): void;
+}
+/**
+ * The half of the engine that is what the host registered
+ * (host-integration.md 4): each definition's source, by the key its
+ * definitions name it by, and the words its keys are checked against
+ * (`EngineText`, D2).
+ */
+export declare abstract class EngineResources {
+    private readonly host;
+    /**
+     * The definitions as registered, keys and all: the registry's map rather
+     * than the registry, so the engine's public type names nothing it does
+     * not export (R2-85).
+     */
+    protected abstract readonly registered: ReadonlyMap<string, ViewDefinition>;
+    /** The words the definitions' keys are checked against; see `EngineText`. */
+    private readonly text;
+    private readonly sources;
+    /** What was told to lack words, by language, code and key; see `setText`. */
+    private readonly lacking;
+    /** Where findings go: the host's `onIssue`, or the development default. */
+    private readonly reporter;
+    constructor(host: ResourceHost);
+    /**
+     * Every registered definition, by id, as it was declared: its keys
+     * (`text(key)`) are said where they are shown (`useSay`, `say`).
+     */
+    get definitions(): ReadonlyMap<string, ViewDefinition>;
+    /**
+     * The words the engine was built with for `key` (`ViewEngineOptions.text`),
+     * or `undefined`: what a surface says a key in where its Provider's words
+     * lack it.
+     */
+    startingWord(key: string): string | undefined;
+    /**
+     * Checks the words a Provider says the definitions' keys in: its
+     * `messages`, in its `language` (host-integration.md 3.1, D2). The
+     * Provider calls this as they change; nothing is redrawn or rebuilt by
+     * it — the keys are said where they are shown.
+     *
+     * The words set are checked on their own: a key they lack reads as
+     * itself (`definition.text.unknown`), or in the words the engine started
+     * with (`definition.text.fallback`) — a Chinese page showing an English
+     * label is a gap too. A fallback is told only of words that say any of
+     * the definitions' keys at all: words that say none (a Provider with no
+     * catalogue of the definitions') leave them to the starting words, as
+     * the host meant. Each key is told once per language, and again once
+     * that language had it and lacks it again.
+     */
+    setText(text: TextResolver | undefined, language?: string): void;
+    /**
+     * A finding with nobody to reject (`onIssue`), with the resource it is
+     * about where there is one.
+     */
+    protected report(found: Issue, resource?: string): void;
+    /** Whether a resource registered a source under `key`. */
+    protected hasSource(key: string): boolean;
+    /** The source registered for a definition's `source` key. */
+    resolveSource(key: string): ViewSource;
+    resolveOptions(key: string): OptionSource;
+}
+//# sourceMappingURL=resources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/runtime/resources.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK5D,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,SAAS;QAClB,UAAU,EAAE,cAAc,CAAC;QAC3B,MAAM,CAAC,EAAE,UAAU,CAAC;KACrB,EAAE,CAAC;IACJ,cAAc,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAC;IAC3C,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACvC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;GAKG;AACH,8BAAsB,eAAe;IAevB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAdjC;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC5E,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;gBAExB,IAAI,EAAE,YAAY;IAkB/C;;;OAGG;IACH,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAErD;IAED;;;;OAIG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,QAAQ,SAAK,GAAG,IAAI;IA6B5D;;;OAGG;IACH,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAIvD,0DAA0D;IAC1D,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzC,6DAA6D;IAC7D,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAStC,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;CAQ1C"}

package/dist/runtime/restyle.d.ts

@@ -0,0 +1,21 @@
+import { RecordViewConfig } from '../model/index.js';
+/**
+ * How much of a record view's question an apply changes, measured against
+ * the config the rows on screen ran under.
+ *
+ * - `drawn`: nothing the source is asked. A column made wider, moved or
+ *   pinned, or a presentation member (`layout`) — the rows stay, and are
+ *   drawn again under the new config.
+ * - `summaries`: that, and the summary row. The aggregation is asked again
+ *   and the page is not.
+ * - `null`: anything else, and the whole query runs.
+ *
+ * Which columns are **shown** is part of the question: the query projects
+ * the fields the table draws (`recordProjection`), so a column switched on
+ * is a field the rows do not hold yet. Their order is not, and neither is
+ * a width or a pin. Before this, every one of those ran the page again — an
+ * Alt+→ on a header was a query, and a reader heard 「正在查询」 and the
+ * record count for each step of a column's width, and never the width.
+ */
+export declare function restyledOnly(ran: RecordViewConfig, next: RecordViewConfig): 'drawn' | 'summaries' | null;
+//# sourceMappingURL=restyle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"restyle.d.ts","sourceRoot":"","sources":["../../src/runtime/restyle.ts"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,gBAAgB,GACrB,OAAO,GAAG,WAAW,GAAG,IAAI,CAK9B"}

package/dist/runtime/routes.d.ts

@@ -0,0 +1,99 @@
+import { DashboardFilters } from '../model/index.js';
+import { DashboardTarget, SavedViewTarget, UnsavedViewTarget, ViewHandOver, ViewNavigation } from './navigation.js';
+/** A way off a board or a view that leads to one of the host's resources. */
+export type RoutedTarget = SavedViewTarget | UnsavedViewTarget | DashboardTarget;
+/** What the page a route opens is handed with it, as history state. */
+export interface ViewRouteState {
+    /** A view to open as it came (`DataWorkbench`'s `handOver`). */
+    handOver?: ViewHandOver;
+    /** A board's filters (`DashboardWorkbench`'s `initialFilters`). */
+    filters?: DashboardFilters;
+    /** The tab a board opens on (`initialTab`); absent, where it was last read. */
+    tab?: string | null;
+    /**
+     * What each board on the page left its filters and tab at, by the board
+     * (`/ui`'s `ViewHost` writes it as the reader changes them): several
+     * boards on one page each find their own again. A board that wrote
+     * nothing here yet reads `filters` and `tab` above.
+     */
+    boards?: Record<string, {
+        filters?: DashboardFilters;
+        tab?: string | null;
+    }>;
+}
+/**
+ * A way off a board or a view, resolved through its definition's `route`:
+ * the host's path, and what the page there is handed.
+ */
+export interface ViewRoute {
+    kind: 'route';
+    path: string;
+    state: ViewRouteState;
+    /** What was asked for, for a host that wants more of it. */
+    target: RoutedTarget;
+}
+/**
+ * What the host's `navigate` is handed: a route, where the target's
+ * definition has one; otherwise the target as it came — a URL, or a
+ * definition the host bound no route for.
+ */
+export type ViewDestination = ViewRoute | ViewNavigation;
+/**
+ * Where a view or a board of a definition lives in the host's address.
+ * `target` is the way off it was asked for; it is absent where the engine
+ * asks for a link rather than a way off — a resource's or a system view's
+ * place in the host's navigation (`useViewNavigation`).
+ */
+export type ViewRouteOf = (instanceId: string | null, target?: RoutedTarget) => string;
+/**
+ * Where the host's router is (host-integration.md 4.2): what the engine
+ * reads the open view (`?view=`), the open record (`?id=`) and what a page
+ * was handed (`ViewRouteState`, the history entry's state) from.
+ */
+export interface ViewLocation {
+    /** The path, without its search: `/orders`. */
+    pathname: string;
+    /** The search, with its `?`, or empty. */
+    search: string;
+    /** The state of the history entry, as the router keeps it. */
+    state: unknown;
+}
+/**
+ * The router port (host-integration.md 4.2): the host's router as the
+ * engine reads and moves it — the one bridge to it, whichever library it
+ * is. `/react-router`'s `useReactRouter` is one; a host on another router
+ * writes these two members over it.
+ *
+ * The contract is the object's identity: **a new `ViewRouter` object
+ * whenever `location` changes, and the same object while it does not.**
+ * `ViewHost` hands it down through context, and everything that reads the
+ * address — the open view, the open record, a board's filters and tab —
+ * re-reads it when, and only when, the object is new. A router mutated in
+ * place is never seen to move; one rebuilt on every render reads the
+ * address anew on every render. Build it with `useMemo` over the
+ * location's parts, as `useReactRouter` does. `go` is read at the moment
+ * it is called, so it may be a new function each time.
+ */
+export interface ViewRouter {
+    /** Where the router is now: a new object, in a new router, as it moves. */
+    readonly location: ViewLocation;
+    /**
+     * Goes to `path` — the host's path, its search included — handing the
+     * page there `state` as the history entry's; `replace` replaces the
+     * entry rather than adding one.
+     */
+    go(path: string, options?: {
+        state?: unknown;
+        replace?: boolean;
+    }): void;
+}
+/**
+ * `to` through the route of the definition it leads to, where it has one
+ * (`bind`'s `route`, looked up by `bindingOf`): what the host's `navigate`
+ * is handed. Pure, and in `/testing` too, so a host's tests of its
+ * bindings run the engine's own resolution.
+ */
+export declare function resolveNavigation(to: ViewNavigation, bindingOf: (definitionId: string) => {
+    route?: ViewRouteOf;
+} | undefined): ViewDestination;
+//# sourceMappingURL=routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/runtime/routes.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACf,MAAM,iBAAiB,CAAC;AAEzB,6EAA6E;AAC7E,MAAM,MAAM,YAAY,GACtB,eAAe,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAExD,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,mEAAmE;IACnE,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,+EAA+E;IAC/E,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CAC9E;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,cAAc,CAAC;IACtB,4DAA4D;IAC5D,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,cAAc,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,MAAM,CAAC,EAAE,YAAY,KAClB,MAAM,CAAC;AAEZ;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,UAAU;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC;;;;OAIG;IACH,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CAC1E;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,cAAc,EAClB,SAAS,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK;IAAE,KAAK,CAAC,EAAE,WAAW,CAAA;CAAE,GAAG,SAAS,GACvE,eAAe,CAoBjB"}

package/dist/runtime/runtimeFactory.d.ts

@@ -0,0 +1,80 @@
+import { FilterTree, RuntimeLimits, ViewConfig, ViewDefinition, ViewInstance, ViewScope } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { RuntimeEnvironment } from './environment.js';
+import { RequestRunner } from './requestRunner.js';
+import { OptionSource, ViewSource } from './source.js';
+import { ManagedViewRuntime } from './viewRuntimeTypes.js';
+import { DefinitionRegistry } from './definitions.js';
+import { SourceCapabilities } from './capabilities.js';
+/** Who a runtime is, apart from the config it holds. */
+export interface RuntimeIdentity {
+    title: string;
+    scope: ViewScope;
+    saved: ViewInstance | null;
+}
+/** What the factory needs from the engine that owns it. */
+export interface RuntimeFactoryHost {
+    readonly definitions: DefinitionRegistry;
+    readonly kinds: FieldKindRegistry;
+    readonly limits: RuntimeLimits;
+    readonly environment: RuntimeEnvironment;
+    readonly runner: RequestRunner;
+    /** Where a definition's data comes from, by `DataViewDefinition.source`. */
+    resolveSource(key: string): ViewSource;
+    /** Remote candidates of `reference` fields; absent when the host wired none. */
+    resolveOptions?(key: string): OptionSource;
+    /** One instance, from the definition's code or from the store. */
+    readInstance(instanceId: string): Promise<ViewInstance>;
+    /**
+     * What each source admits: a definition as its descriptor narrows it and
+     * the limits a runtime over it runs under (`effective`, which throws
+     * where the descriptor contradicts the definition).
+     */
+    readonly capabilities: SourceCapabilities;
+}
+export declare class RuntimeFactory {
+    private readonly host;
+    private sequence;
+    constructor(host: RuntimeFactoryHost);
+    build(definition: ViewDefinition, config: ViewConfig, identity: RuntimeIdentity, scopeFilter?: FilterTree | null): ManagedViewRuntime;
+    private buildData;
+    private buildDashboard;
+    /**
+     * Holds room in the query queue for a board's panels while it is open
+     * (`RequestRunner.reserve`): each may ask up to `QUERIES_PER_PANEL` at
+     * once — its own, a split's 「其他」, a cut's probe — so a board of any
+     * size opens whole rather than having its last panels refused. The room
+     * follows the board as panels are added or taken away, and is given back
+     * when it closes.
+     */
+    private holdRoom;
+    /** What a panel references: the instance and the definition behind it. */
+    private readonly resolvePanel;
+    /**
+     * The definition a view a board owns is of: code, so looked up rather
+     * than loaded, and `null` for one this release does not declare or one
+     * that failed admission — neither can be run.
+     */
+    private readonly panelDefinition;
+    /**
+     * A panel's definition as its source admits it, so the board judges a
+     * panel against the same fields its child runtime runs on.
+     */
+    private admitted;
+    /**
+     * One panel's child runtime. It is owned by its dashboard rather than by
+     * the engine: it is not saved, renamed or deleted through a command, and it
+     * runs no timer of its own, because the dashboard times every panel. A
+     * view the board owns has no baseline (`saved` is `null`): it is saved
+     * with the board, never on its own.
+     */
+    private readonly createPanelRuntime;
+    /**
+     * How a runtime over `definition` follows its source's descriptor: the
+     * definition as declared (a panel may hold one already narrowed), what is
+     * in force now, and the source's changes.
+     */
+    private follow;
+    private newRuntimeId;
+}
+//# sourceMappingURL=runtimeFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeFactory.d.ts","sourceRoot":"","sources":["../../src/runtime/runtimeFactory.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAIV,UAAU,EACV,aAAa,EACb,UAAU,EACV,cAAc,EACd,YAAY,EACZ,SAAS,EACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAS,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG5D,OAAO,KAAK,EACV,kBAAkB,EAEnB,MAAM,uBAAuB,CAAC;AAM/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAK5D,wDAAwD;AACxD,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;CAC5B;AAED,2DAA2D;AAC3D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,4EAA4E;IAC5E,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IACvC,gFAAgF;IAChF,cAAc,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAC;IAC3C,kEAAkE;IAClE,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACxD;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;CAC3C;AAKD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAK;gBAET,IAAI,EAAE,kBAAkB;IAIpC,KAAK,CACH,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,eAAe,EACzB,WAAW,GAAE,UAAU,GAAG,IAAW,GACpC,kBAAkB;IAUrB,OAAO,CAAC,SAAS;IAmCjB,OAAO,CAAC,cAAc;IAwDtB;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ;IAsBhB,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAe3B;IAEF;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAW9B;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAMhB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAwBjC;IAEF;;;;OAIG;IACH,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,YAAY;CAGrB"}

package/dist/runtime/runtimeStore.d.ts

@@ -0,0 +1,187 @@
+import { Issue, ViewConfig, ViewInstance } from '../model/index.js';
+import { RuntimeEnvironment } from './environment.js';
+import { ViewRuntimeState } from './viewRuntimeTypes.js';
+/** An `error` blocks apply and every write; a `warning` only reports. */
+export declare function hasError(issues: readonly Issue[]): boolean;
+/**
+ * What the store asks of the runtime holding it: the few steps that are not
+ * the store's to decide.
+ *
+ * Each one is where the two runtimes genuinely differ. `admit` is the one
+ * rule a class holds its configs to — a data view judges against its
+ * definition, a dashboard against its panels and their references — and
+ * `apply` is what promotion means there: one query, or N children brought
+ * into line. The rest is the same both times, and therefore lives in the
+ * store rather than in two copies of it.
+ */
+export interface RuntimeStoreHost<S extends ViewRuntimeState<ViewConfig>> {
+    /** Admission of a draft as it would run, scope filter included. */
+    admit(draft: S['draft']): Issue[];
+    /** Promotes the draft and puts it in force; `revert` re-applies through it. */
+    apply(): void;
+    /** What the refresh timer fires when it comes due. */
+    refresh(): void;
+    /**
+     * The runtime's own reason to hold the timer, beyond the three the store
+     * reads for itself (an invalid draft, an editor with focus, a hidden page).
+     *
+     * That reason is "a request in flight", and only the runtime knows whose:
+     * a data view's is its own, a dashboard's is any panel's. A data view
+     * inside a dashboard answers true for good — the board times every panel,
+     * so a panel runs no clock of its own.
+     */
+    holding(): boolean;
+    /**
+     * The interval the timer keeps, where it is not `applied`'s: a
+     * dashboard's reader may keep one of their own for the opening, beside
+     * the draft (D26 Q35). Left out, `applied`'s.
+     */
+    interval?(): number | null;
+    /** Whatever the runtime holds besides the store, let go of on `dispose`. */
+    release(): void;
+    /**
+     * A draft that has just replaced the one on screen without an edit having
+     * made it — `revert`. A dashboard starts loading the references the
+     * restored panels name; a data view has nothing to do here, which is the
+     * one line the two `revert`s used to differ by.
+     */
+    restored?(draft: S['draft']): void;
+    /**
+     * Whether these issues stop the runtime from applying, and so hold its
+     * timer. Any error does, for a data view — its config is one query. A
+     * dashboard answers only for errors about the board itself: a panel's own
+     * error stops that panel, and the board keeps applying and refreshing the
+     * rest (`blocksBoard`).
+     */
+    blocking?(issues: readonly Issue[]): boolean;
+    /**
+     * The moment what is on screen stops being true of its own accord, on the
+     * environment's clock — a metric card's headline, once the period it
+     * skipped as under way has ended (`periodRollover`) — or `null`. The store
+     * refreshes then, whatever the auto-refresh cadence, and held for the
+     * same reasons it is: a hidden page asks once it is shown again.
+     */
+    expiresAt?(): number | null;
+}
+/**
+ * How long past the moment a period ends the question is asked again: the
+ * source has had a second to close the bucket that just ended.
+ */
+export declare const ROLLOVER_GRACE_MS = 1000;
+export interface RuntimeStoreOptions<S extends ViewRuntimeState<ViewConfig>> extends RuntimeStoreHost<S> {
+    /** The state the view opens on, already judged by the caller's `admit`. */
+    state: S;
+    environment: RuntimeEnvironment;
+    /**
+     * What the scope this view opened under was refused for, or empty while it
+     * is in force. It is settled before the store exists — the config and the
+     * injected condition are admitted together (D17-5) — so it comes in rather
+     * than being asked for.
+     */
+    refusedScope?: Issue[];
+}
+/**
+ * The store half of a runtime: the state it holds, who is watching it, the
+ * refresh timer's bookkeeping, and whether the draft has moved away from what
+ * was saved.
+ *
+ * A `ViewRuntime` is two things at once. One is a kind of view — a record
+ * page with paging and a selection, or a board of panels — and that part is
+ * the runtime class's own. The other is a `subscribe` / `getSnapshot` store,
+ * and that part was the same code twice over, down to the comments: commit
+ * before notifying, keep the previous refusal while it says the same thing,
+ * write the due time where the timer is armed and clear it where it stops.
+ * Those rules are here now, once, and the two runtimes hold one of these
+ * each.
+ *
+ * It is generic in the whole snapshot rather than in the config, because a
+ * dashboard's snapshot is a `ViewRuntimeState` with the panels added: the
+ * store patches and hands out whatever its holder declared, without knowing
+ * what else is in it.
+ */
+export declare class RuntimeStore<S extends ViewRuntimeState<ViewConfig>> {
+    private readonly listeners;
+    private readonly environment;
+    private readonly host;
+    private readonly timer;
+    private readonly rollover;
+    private readonly unwatchVisibility;
+    private current;
+    private refusal;
+    private stopped;
+    constructor(options: RuntimeStoreOptions<S>);
+    /** The snapshot as it stands, for the runtime's own commands to read. */
+    get state(): S;
+    /**
+     * See `ViewRuntime.getSnapshot`: the state as it is, keys and all
+     * (`text(key)`) — whatever shows it says them (D2).
+     */
+    getSnapshot(): S;
+    /** The members a new baseline moves: `stored`, as the store holds it. */
+    baseline(stored: ViewInstance): Partial<S>;
+    /** True once disposed: every command of the runtime is a no-op from then on. */
+    get disposed(): boolean;
+    /** See `ViewRuntime.refusedScope`; written by `refuse`, read through the runtime. */
+    get refusedScope(): Issue[];
+    subscribe(listener: () => void): () => void;
+    setState(patch: Partial<S>): void;
+    notify(): void;
+    /**
+     * Whether the draft says something other than what was saved.
+     *
+     * A view that was never saved has nothing to compare against, and closing
+     * it would lose everything, so it counts as dirty from the start. Both
+     * hold keys where a definition wrote them, so they compare in no language.
+     */
+    isDirty(draft: S['draft'], saved: ViewInstance | null): boolean;
+    /**
+     * Records what the scope on hand was refused for, and tells the subscribers
+     * when that answer changed.
+     *
+     * A refusal changes nothing else — no state, no query — so without this a
+     * screen showing it would have to be told by whoever made the injection,
+     * which is how a refusal on open came to say something else entirely. The
+     * previous answer is kept while it says the same thing, so a host that
+     * builds its condition in render is not re-rendered forever.
+     */
+    refuse(refusal: Issue[]): Issue[];
+    /**
+     * Discards the edits and re-runs what was saved.
+     *
+     * It re-applies rather than only restoring the draft, because the results
+     * on screen may already answer a question the user has just taken back —
+     * leaving them there would show the reverted config's rows under the saved
+     * config's name. A draft the store's own config cannot pass admission for
+     * is restored all the same and left for the user to fix, since refusing
+     * would strand them on edits they asked to be rid of. A view that was never
+     * saved has no baseline to return to, so it is a no-op there.
+     */
+    revert(): void;
+    /**
+     * Re-syncs the timer for something that is not a state change of the
+     * runtime's own — the page being hidden or shown, a panel's query starting
+     * or landing — and notifies only if the due time moved.
+     *
+     * Visibility does not change `draft`, `applied` or the query, so there
+     * would be nothing to tell a subscriber about without this, and a countdown
+     * on screen would go on counting to a timer that is no longer armed. It is
+     * at most twice a round however many panels there are, which is what keeps
+     * a grid from re-rendering on every panel request.
+     */
+    retime(): void;
+    dispose(): void;
+    /**
+     * Auto-refresh: the four reasons to hold the timer are read here — three of
+     * them off the snapshot and the environment, the fourth asked of the runtime
+     * (`RuntimeStoreHost.holding`) — and arming is `RefreshTimer`'s. The due
+     * time is written into the snapshot without notifying: every caller is
+     * either `setState`, which notifies after it, or `retime`, which notifies
+     * for it.
+     */
+    private syncTimer;
+    /** See `RuntimeStoreHost.blocking`; any error, unless the runtime says otherwise. */
+    private blocking;
+    private setDueAt;
+    private stopTimer;
+}
+//# sourceMappingURL=runtimeStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeStore.d.ts","sourceRoot":"","sources":["../../src/runtime/runtimeStore.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAS3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,CAAC,UAAU,CAAC;IACtE,mEAAmE;IACnE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC;IAClC,+EAA+E;IAC/E,KAAK,IAAI,IAAI,CAAC;IACd,sDAAsD;IACtD,OAAO,IAAI,IAAI,CAAC;IAChB;;;;;;;;OAQG;IACH,OAAO,IAAI,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,MAAM,GAAG,IAAI,CAAC;IAC3B,4EAA4E;IAC5E,OAAO,IAAI,IAAI,CAAC;IAChB;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IACnC;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAAC;IAC7C;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC,MAAM,WAAW,mBAAmB,CAClC,CAAC,SAAS,gBAAgB,CAAC,UAAU,CAAC,CACtC,SAAQ,gBAAgB,CAAC,CAAC,CAAC;IAC3B,2EAA2E;IAC3E,KAAK,EAAE,CAAC,CAAC;IACT,WAAW,EAAE,kBAAkB,CAAC;IAChC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,gBAAgB,CAAC,UAAU,CAAC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;IAC3C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAa;IAE/C,OAAO,CAAC,OAAO,CAAI;IACnB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAgB3C,yEAAyE;IACzE,IAAI,KAAK,IAAI,CAAC,CAEb;IAED;;;OAGG;IACH,WAAW,IAAI,CAAC;IAIhB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC;IAU1C,gFAAgF;IAChF,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,qFAAqF;IACrF,IAAI,YAAY,IAAI,KAAK,EAAE,CAE1B;IAED,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;IAOjC,MAAM,IAAI,IAAI;IAId;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,GAAG,OAAO;IAI/D;;;;;;;;;OASG;IACH,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE;IAOjC;;;;;;;;;;OAUG;IACH,MAAM,IAAI,IAAI;IAiBd;;;;;;;;;;OAUG;IACH,MAAM,IAAI,IAAI;IAOd,OAAO,IAAI,IAAI;IAYf;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IA2BjB,qFAAqF;IACrF,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,SAAS;CAKlB"}

package/dist/runtime/savedConditions.d.ts

@@ -0,0 +1,11 @@
+import { ViewConfig, ViewInstance } from '../model/index.js';
+/**
+ * Whether the conditions in force are other than the ones the view was saved
+ * with — `null` when it was never saved, or is not a data view with
+ * conditions of its own. The empty result of a record view and of an
+ * analysis reads it to choose its way out: back to the saved conditions, or
+ * on to another question (`emptyWayOut`). A dashboard has no conditions of
+ * its own (D27), and no one result of its is empty.
+ */
+export declare function conditionsDrifted(applied: ViewConfig, saved: ViewInstance | null): boolean | null;
+//# sourceMappingURL=savedConditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"savedConditions.d.ts","sourceRoot":"","sources":["../../src/runtime/savedConditions.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAElE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,YAAY,GAAG,IAAI,GACzB,OAAO,GAAG,IAAI,CAKhB"}

package/dist/runtime/scope.d.ts

@@ -0,0 +1,50 @@
+import { DataViewConfig, FilterTree, Issue } from '../model/index.js';
+/** Stable identity for "nothing was refused", so a reader can compare. */
+export declare const NO_REFUSAL: Issue[];
+/**
+ * A config as it would run: the scope filter ANDed after its own conditions.
+ *
+ * A root that is not a group is admission's to report as it stands; merging
+ * would turn it into a condition, or lose it.
+ */
+export declare function withScopeFilter<C extends DataViewConfig>(config: C, scope: FilterTree | null): C;
+/**
+ * Findings on a config judged with its scope, read as findings on the config.
+ *
+ * Two things the merge does must not leak into the issues. The `filterMode`
+ * warning judges what the editor can show, which is the config's own tree;
+ * the merged tree is never simple, so the warning is dropped when the draft
+ * itself is simple. And a root that is not `and` rides in the merged tree
+ * as its first child, so a finding at `['children', 0, …]` is a finding at
+ * `[…]` of the draft, and is addressed so — every reader of `issues` reads
+ * a path against the draft.
+ */
+export declare function withoutScopeModeWarning(issues: Issue[], config: DataViewConfig, scope: FilterTree | null): Issue[];
+/**
+ * What an injected scope is refused for: the errors admitting the config with
+ * it raises that the config does not raise on its own.
+ *
+ * The merged findings hold both — the host's condition and whatever the saved
+ * view already carried — and only the first kind is a refusal (D17-5). A view
+ * that needs fixing is not fixed by leaving the host's condition out, so its
+ * own errors keep being the view's; and a host told "this view must be fixed"
+ * has nothing it can do about somebody else's saved config, so a refusal must
+ * name the one thing the host can take back.
+ *
+ * Paths survive the merge — the scope is appended after the config's own
+ * conditions, and `withoutScopeModeWarning` puts a nested root's back — so a
+ * finding is matched by code and path, and one for one: a config carrying an
+ * error twice is not answered by a merged tree raising it three times.
+ */
+export declare function scopeRefusal(own: Issue[], merged: Issue[]): Issue[];
+/**
+ * Whether two refusals say the same thing.
+ *
+ * Admission builds fresh issues every time, so a runtime that kept every
+ * answer would report a change on every injection — and a host passing a
+ * condition object built in render would then never stop re-rendering. The
+ * refusal on hand is kept while it says the same, and only a different one
+ * is a change worth telling anybody about.
+ */
+export declare function sameRefusal(left: readonly Issue[], right: readonly Issue[]): boolean;
+//# sourceMappingURL=scope.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/runtime/scope.ts"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG3E,0EAA0E;AAC1E,eAAO,MAAM,UAAU,EAAE,KAAK,EAAO,CAAC;AAEtC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,cAAc,EACtD,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,UAAU,GAAG,IAAI,GACvB,CAAC,CAGH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,KAAK,EAAE,EACf,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,UAAU,GAAG,IAAI,GACvB,KAAK,EAAE,CAUT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CAUnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,KAAK,EAAE,SAAS,KAAK,EAAE,GACtB,OAAO,CAKT"}