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

package/dist/runtime/execute.d.ts

@@ -0,0 +1,70 @@
+import { RecordProjection } from '../record/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { DataViewConfig, DataViewDefinition, Issue, ViewConfig, RecordPageTarget, RecordViewConfig, RuntimeLimits } from '../model/index.js';
+import { RuntimeEnvironment } from './environment.js';
+import { QueryFailureReporter } from './failures.js';
+import { ProjectedView, ViewSource } from './source.js';
+/** Everything an execution needs besides the config itself. */
+export interface KernelContext {
+    definition: DataViewDefinition;
+    kinds: FieldKindRegistry;
+    limits: RuntimeLimits;
+    environment: RuntimeEnvironment;
+    source: ViewSource;
+    /**
+     * Tells the host of a query that failed where nothing rejects to a caller
+     * who would: a summary, a total or a split answered without (D40). The
+     * view's own query is told by the runtime, which knows whether it still
+     * counts. The report waits for the source's answer to be read, so it can
+     * say the rule a Wow service said the query broke (D40).
+     */
+    queryFailed: QueryFailureReporter;
+}
+/** Admission, dispatched by kind. Both kernels take the same three inputs. */
+export declare function validateDataConfig(context: Pick<KernelContext, 'definition' | 'kinds' | 'limits'>, config: DataViewConfig): Issue[];
+/** The first page of the definition's paging mode. */
+export declare function firstPageOf(definition: DataViewDefinition): RecordPageTarget | undefined;
+/**
+ * Compiles, queries and projects, in one scheduler slot.
+ *
+ * Summaries and totals travel with their main query rather than taking a slot
+ * of their own: they belong to the same view of the same moment, and a second
+ * slot would let them supersede or outlive it.
+ */
+export declare function executeDataConfig(context: KernelContext, config: DataViewConfig, page: RecordPageTarget | undefined, controller: AbortController): Promise<ProjectedView>;
+/**
+ * The summary row again, over rows already on screen.
+ *
+ * A record view whose summaries changed and nothing else (`restyledOnly`)
+ * asks the source for the aggregation alone: the page it would fetch with it
+ * is the page it has, so fetching it again would only say 「正在查询」 over
+ * rows that do not change. `view` is those rows, already drawn under the
+ * new config; the aggregation failing falls back to adding them up, as it
+ * does beside a page.
+ */
+export declare function executeSummaries(context: KernelContext, config: RecordViewConfig, view: RecordProjection, controller: AbortController): Promise<ProjectedView>;
+/**
+ * The findings a result makes about the groups below its last row
+ * (`cutShortIssues`). A workbench draws them beside the result they are
+ * about rather than in the status line over the whole view: a sentence
+ * about the rows belongs where the rows are (2026-09-23 audit).
+ */
+export declare const CUT_SHORT_CODES: readonly string[];
+/**
+ * The last result's findings as the screen draws them now
+ * (`resultIssues`), the groups cut short judged again for the layout and
+ * the chart in the draft: a redraw — table to chart, bars to a pie — runs
+ * nothing, so the finding the run made described the chart it ran with,
+ * and a ranking redrawn as a pie said nothing until it was saved and
+ * opened again, then went on warning as the table (second review
+ * R2-P1-1). The facts are the run's (`truncated`, `atLimit`, its sort and
+ * limit); only how the rows are drawn is the draft's.
+ */
+export declare function drawnResultIssues(state: {
+    draft: ViewConfig;
+    result: {
+        config: ViewConfig;
+        data: ProjectedView;
+    } | null;
+} | null | undefined): readonly Issue[];
+//# sourceMappingURL=execute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/runtime/execute.ts"],"names":[],"mappings":"AAcA,OAAO,EAOL,KAAK,gBAAgB,EAEtB,MAAM,oBAAoB,CAAC;AAW5B,OAAO,EAEL,KAAK,iBAAiB,EAEvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAEV,cAAc,EACd,kBAAkB,EAClB,KAAK,EACL,UAAU,EAEV,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAe,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAgB,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAShF,+DAA+D;AAC/D,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,iBAAiB,CAAC;IACzB,MAAM,EAAE,aAAa,CAAC;IACtB,WAAW,EAAE,kBAAkB,CAAC;IAChC,MAAM,EAAE,UAAU,CAAC;IACnB;;;;;;OAMG;IACH,WAAW,EAAE,oBAAoB,CAAC;CACnC;AAED,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC,EAC/D,MAAM,EAAE,cAAc,GACrB,KAAK,EAAE,CAcT;AA4DD,sDAAsD;AACtD,wBAAgB,WAAW,CACzB,UAAU,EAAE,kBAAkB,GAC7B,gBAAgB,GAAG,SAAS,CAG9B;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAClC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,aAAa,CAAC,CAQxB;AA2CD;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,eAAe,GAC1B,OAAO,CAAC,aAAa,CAAC,CA2BxB;AAsMD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAG5C,CAAC;AAmDF;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EACD;IACE,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAE,GAAG,IAAI,CAAC;CAC5D,GACD,IAAI,GACJ,SAAS,GACZ,SAAS,KAAK,EAAE,CAkBlB"}

package/dist/runtime/exportRows.d.ts

@@ -0,0 +1,67 @@
+import { RecordCapability, RecordData, RecordViewConfig, RuntimeLimits } from '../model/index.js';
+import { KernelContext } from './execute.js';
+export interface ExportRowsOptions {
+    /** Stops the run; the promise then rejects with an `ExportCancelledError`. */
+    signal?: AbortSignal;
+    /**
+     * How far it has got: rows in hand, and how many there are in all when the
+     * source says. A cursor source never says, which is why the total is
+     * optional rather than a number nobody can compute.
+     */
+    onProgress?(fetched: number, total?: number): void;
+    /** The ceiling; `limits.exportMax` when left out. */
+    max?: number;
+}
+export interface ExportedRows {
+    rows: RecordData[];
+    /** What the source said there are in all, when it says at all. */
+    total?: number;
+    /** True when the ceiling stopped it while the source still had rows. */
+    capped: boolean;
+}
+/**
+ * What a cancelled export rejects with. It is not a failure — nobody has to
+ * be told about it — so the caller tells it apart rather than reporting it.
+ */
+export declare class ExportCancelledError extends Error {
+    constructor();
+}
+/** By name, as every guard of the engine's errors (`isViewStoreError`). */
+export declare function isExportCancelledError(error: unknown): error is ExportCancelledError;
+/**
+ * How an export pages its source: the size it asks for, and the most rows it
+ * may carry away.
+ *
+ * The ceiling is `limits.exportMax`, and below it a paged source's window
+ * (`pageWindow`: the runtime's `maxPageWindow`, or the definition's
+ * `maxWindow` where it is the smaller): a page past the
+ * window is refused outright, so an export that went on asking would fail on
+ * the page after the last one it could have, having fetched every row before
+ * it. The size shrinks to the window when the window is the smaller, and the
+ * ceiling stops at the last whole page inside it — the same count the pager
+ * stops at. `ExportDialog` states this ceiling before anything is fetched.
+ */
+export declare function exportPlan(limits: Pick<RuntimeLimits, 'exportMax' | 'maxPageSize'> & Partial<Pick<RuntimeLimits, 'maxPageWindow'>>, capability?: Partial<Pick<RecordCapability, 'maxWindow' | 'paging'>>, asked?: number): {
+    size: number;
+    max: number;
+};
+/**
+ * Every row the applied conditions match, paged out of the source behind the
+ * screen.
+ *
+ * It is a query of its own and deliberately beside the runtime's: it takes no
+ * scheduler slot, never becomes `state.result` and cannot supersede — or be
+ * superseded by — what the user is looking at. Export is a read the user asked
+ * for *in addition to* the view, and a view that emptied itself because an
+ * export was running would be the worse answer.
+ *
+ * The page size is the runtime's `maxPageSize` rather than the view's, since
+ * the page on screen has nothing to do with it: the fewer round trips the
+ * better, and that ceiling is exactly what the source was admitted for.
+ *
+ * `ctx.now` is read once, at the start, so a relative condition means the same
+ * thing on the last page as on the first — twenty pages apart, "today" must
+ * not roll over into tomorrow halfway through one file.
+ */
+export declare function fetchExportRows(context: KernelContext, config: RecordViewConfig, options?: ExportRowsOptions): Promise<ExportedRows>;
+//# sourceMappingURL=exportRows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exportRows.d.ts","sourceRoot":"","sources":["../../src/runtime/exportRows.ts"],"names":[],"mappings":"AAqBA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEf,KAAK,gBAAgB,EACrB,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,8EAA8E;IAC9E,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;OAIG;IACH,UAAU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,qDAAqD;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;;CAK9C;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oBAAoB,CAE/B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,WAAW,GAAG,aAAa,CAAC,GACtD,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,EAC/C,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,WAAW,GAAG,QAAQ,CAAC,CAAC,EACpE,KAAK,CAAC,EAAE,MAAM,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAkB/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,YAAY,CAAC,CA0CvB"}

package/dist/runtime/failures.d.ts

@@ -0,0 +1,57 @@
+import { ViewStore } from '../store/ViewStore.js';
+import { ViewRuntime } from './viewRuntimeTypes.js';
+import { RuntimeEnvironment, ViewErrorContext, ViewErrorEvent, ViewErrorKind } from './environment.js';
+/** Where a failure happened, less what it was doing. */
+export type FailurePlace = Omit<ViewErrorContext, 'operation'>;
+/**
+ * Hands one failure to the host's `onError` (D40), and nothing else: no
+ * console, no rethrow. The hook is the host's code running inside the
+ * engine's own paths — a query settling, a write being recorded, a boundary
+ * catching — so whatever it throws, or a promise it returns rejects with,
+ * is dropped here rather than taking that path down with it.
+ */
+export declare function reportError(environment: Pick<RuntimeEnvironment, 'onError'> | undefined, event: ViewErrorEvent): void;
+/**
+ * Whether a rejection is a request being called off — by its own signal, or
+ * as an `AbortError` — rather than a failure. Called off is what typing
+ * does, and closing a view: nobody is told.
+ */
+export declare function isCalledOff(error: unknown, signal?: AbortSignal): boolean;
+/** Tells the host of one failure of a kind already chosen. */
+export type FailureReporter = (operation: string, error: unknown, place?: FailurePlace) => void;
+/**
+ * A reporter for one kind, with what is known of where it runs read at the
+ * moment of the failure — a view saved since it opened says its id.
+ */
+export declare function failureReporter(environment: Pick<RuntimeEnvironment, 'onError'>, kind: ViewErrorKind, known?: () => FailurePlace): FailureReporter;
+/**
+ * Tells the host of one failed query, once the source's answer has been
+ * read (D40): the report says the service's `errorCode` as it gave it, and
+ * which rule a Wow service said the query broke and where
+ * (`context.violation`), so it waits for the body. The read is the
+ * one the Issue on screen reads too (`sourceFailure` reads a failure once),
+ * and the promise it returns never rejects.
+ */
+export type QueryFailureReporter = (operation: string, error: unknown, place?: FailurePlace) => Promise<void>;
+/** A `query` reporter that reads the source's answer first; see above. */
+export declare function queryFailureReporter(environment: Pick<RuntimeEnvironment, 'onError'>, known?: () => FailurePlace): QueryFailureReporter;
+/**
+ * The store as the engine calls it: every rejection of every call is told
+ * to the host once, as a `store` failure. It is said here, at the one door
+ * every read and write passes through, so a failure the list, the write
+ * ledger, a board's reference and the tab memory each answer in their own
+ * way is still said exactly once, and no caller has to remember to. A call
+ * aborted by its own signal is not a failure. `permissions` is a synchronous
+ * answer rather than a request, and is passed on as it is.
+ */
+export declare function reportingStore(store: ViewStore, environment: Pick<RuntimeEnvironment, 'onError'>): ViewStore;
+/**
+ * Tells the host of a failure met beside an open view rather than inside
+ * it — a file that could not be handed over, a picture that could not be
+ * drawn — through the environment that view runs on, saying which view.
+ * No view, no one to tell.
+ */
+export declare function reportViewFailure(runtime: ViewRuntime | null | undefined, kind: ViewErrorKind, operation: string, error: unknown): void;
+/** Which view: its definition, its saved id if it has one, its runtime. */
+export declare function viewPlace(runtime: ViewRuntime): FailurePlace;
+//# sourceMappingURL=failures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"failures.d.ts","sourceRoot":"","sources":["../../src/runtime/failures.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACd,MAAM,kBAAkB,CAAC;AAE1B,wDAAwD;AACxD,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,WAAW,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC,GAAG,SAAS,EAC5D,KAAK,EAAE,cAAc,GACpB,IAAI,CASN;AAUD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAOzE;AAED,8DAA8D;AAC9D,MAAM,MAAM,eAAe,GAAG,CAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,EACd,KAAK,CAAC,EAAE,YAAY,KACjB,IAAI,CAAC;AAEV;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC,EAChD,IAAI,EAAE,aAAa,EACnB,KAAK,GAAE,MAAM,YAAyB,GACrC,eAAe,CAOjB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG,CACjC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,EACd,KAAK,CAAC,EAAE,YAAY,KACjB,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,0EAA0E;AAC1E,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC,EAChD,KAAK,GAAE,MAAM,YAAyB,GACrC,oBAAoB,CAatB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC,GAC/C,SAAS,CA8EX;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACvC,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,GACb,IAAI,CAON;AAED,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,YAAY,CAO5D"}

package/dist/runtime/fetchRecord.d.ts

@@ -0,0 +1,20 @@
+import { FilterTree, RecordData, RecordKey, RecordViewConfig } from '../model/index.js';
+import { KernelContext } from './execute.js';
+/**
+ * One record, whole, by its row key — what a detail panel reads.
+ *
+ * A page of rows carries what the page shows, and a record's detail is
+ * everything the definition declares about it: the error message a column
+ * clipped, the stack trace no column holds. So it is asked for on its own,
+ * the way a service answers "this one": the row key equal to `key`, within
+ * the scope the host injected (a tenant's view never opens another tenant's
+ * record) and **nothing else** — not the conditions the page was found by. A
+ * record opened from the page may stop matching them the moment a command
+ * changes it (a retried failure is no longer 「失败」), and its detail is
+ * about the record, not about the list.
+ *
+ * Answers `null` when the record is no longer there. Runs beside the view,
+ * as an export does: no scheduler slot, and the rows on screen untouched.
+ */
+export declare function fetchRecord(context: KernelContext, config: RecordViewConfig, scope: FilterTree | null, key: RecordKey, signal?: AbortSignal): Promise<RecordData | null>;
+//# sourceMappingURL=fetchRecord.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchRecord.d.ts","sourceRoot":"","sources":["../../src/runtime/fetchRecord.ts"],"names":[],"mappings":"AAcA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAIlD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,UAAU,GAAG,IAAI,EACxB,GAAG,EAAE,SAAS,EACd,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAsC5B"}

package/dist/runtime/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Transient state: what is open, what is in flight, what came back.
+ *
+ * This is the only layer with a clock, a timer and a queue, and it reaches all
+ * three through an injected `RuntimeEnvironment`, so the kernels below it stay
+ * pure and the React layer above it only subscribes.
+ *
+ * This file is the runtime's **public** face, named export by export (A-16,
+ * D29): what a host holds — the engine, the runtime contracts and every type
+ * their signatures name, the environment and the source ports — and nothing
+ * the engine is built from. The scheduler, the store the runtimes are made
+ * of, the timers, the listener sets, the runtime classes and the readings
+ * `/react` and `/ui` share stay behind it; those two layers import them from
+ * their own modules. A name added here is a name promised, and
+ * `test/publicSurface.test.ts` says so.
+ */
+export { ViewEngine, type ViewEngineOptions, type ViewListing, } from './viewEngine.js';
+export type { ConflictChoice, WriteTarget } from './writeLedger.js';
+export { validateDefinition, type ValidateDefinitionOptions, } from './validateDefinition.js';
+export { hasAsked, hasResult, type AnyViewRuntime, type CreateInput, type DefinitionFor, type OpenOptions, type QueryStatus, type RecordViewRuntime, type RuntimeFor, type ViewQueryState, type ViewResult, type ViewRuntime, type ViewRuntimeState, } from './viewRuntimeTypes.js';
+export { isRecordRuntime } from './recordRuntime.js';
+export { ExportCancelledError, isExportCancelledError, type ExportedRows, type ExportRowsOptions, } from './exportRows.js';
+export type { ValueCandidateSource } from './valueCandidates.js';
+export type { DashboardRuntime, DashboardRuntimeState, HeldFilters, } from './dashboard/contract.js';
+export type { DashboardPanelState } from './dashboard/panels.js';
+export type { DashboardEditing, DashboardFilterEditing, } from './dashboard/editing.js';
+export type { EditCommand, EditHistoryState, EditStep, } from './dashboard/history.js';
+export type { PanelGrouping } from './dashboard/grouping.js';
+export type { CrossFilterOutcome, DestinationBoard, PressDestination, } from './dashboard/press.js';
+export type { BoardOrigin, DashboardTarget, GroupNaming, HandOver, SavedViewTarget, UnsavedViewTarget, ViewHandOver, ViewNavigation, } from './navigation.js';
+export { isViewCommandError, isViewWriteError, ViewCommandError, ViewWriteError, type WriteAction, type WriteHandle, type WritePayload, type WriteState, } from './write.js';
+export type { ViewChange, ViewChangeKind, ViewChangeListener, } from './viewChanges.js';
+export { ALWAYS_VISIBLE, defaultRuntimeEnvironment, type RuntimeEnvironment, type ViewErrorContext, type ViewErrorEvent, type ViewErrorKind, type VisibilitySource, } from './environment.js';
+export type { OptionSource, ProjectedAnalysis, ProjectedBase, ProjectedRecord, ProjectedView, ViewSource, } from './source.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,WAAW,GACjB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,GAC/B,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,QAAQ,EACR,SAAS,EACT,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,gBAAgB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,iBAAiB,GACvB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAGjE,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACrB,WAAW,GACZ,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,YAAY,EACV,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,QAAQ,GACT,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAG9B,YAAY,EACV,WAAW,EACX,eAAe,EACf,WAAW,EACX,QAAQ,EACR,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,UAAU,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,UAAU,EACV,cAAc,EACd,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,aAAa,EACb,UAAU,GACX,MAAM,aAAa,CAAC"}

package/dist/runtime/issueReport.d.ts

@@ -0,0 +1,25 @@
+import { Issue } from '../model/index.js';
+/** Told of one finding, with the resource it is about where there is one. */
+export type IssueReporter = (found: Issue, resource?: string) => void;
+/** The part of `console` the report writes to. */
+export interface IssueConsole {
+    groupCollapsed(...data: unknown[]): void;
+    groupEnd(): void;
+    warn(...data: unknown[]): void;
+    error(...data: unknown[]): void;
+    info(...data: unknown[]): void;
+}
+/** The hint for `code`, or `undefined` for a code with none. */
+export declare function issueHint(code: string): string | undefined;
+/**
+ * A reporter that writes to `sink`, one collapsed group per resource for
+ * the findings of the same turn — an engine's start reports every
+ * definition's at once — each finding on its own line with its hint.
+ */
+export declare function consoleIssueReporter(sink: IssueConsole): IssueReporter;
+/**
+ * The reporter an engine uses when its host passes no `onIssue`: the
+ * console's, in development; none otherwise.
+ */
+export declare function defaultIssueReporter(): IssueReporter | undefined;
+//# sourceMappingURL=issueReport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"issueReport.d.ts","sourceRoot":"","sources":["../../src/runtime/issueReport.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,6EAA6E;AAC7E,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAEtE,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC3B,cAAc,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACzC,QAAQ,IAAI,IAAI,CAAC;IACjB,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAC/B,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChC,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CAChC;AA8DD,gEAAgE;AAChE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS1D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,aAAa,CA8BtE;AAoBD;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,aAAa,GAAG,SAAS,CAEhE"}

package/dist/runtime/issues.d.ts

@@ -0,0 +1,35 @@
+import { Issue, ViewStoreError } from '../model/index.js';
+/**
+ * One Issue for whatever a command threw, so a caller renders a single
+ * shape. A refusal already carries its Issue; a store failure keeps its code;
+ * anything else keeps its message.
+ *
+ * It lives here rather than in `/react` because the engine itself has to
+ * say what a store's failure was — a list that could not be read is an
+ * answer with a reason in it, not an exception (see `ViewEngine.list`).
+ */
+export declare function toIssue(error: unknown, code: string): Issue;
+/**
+ * `toIssue` for a failure that may have come from a source: a query or an
+ * export over the host's data. What the engine's own commands and stores
+ * say is read as `toIssue` reads it; anything else is asked for the
+ * source's own reason (`sourceReason`), which may take reading a body.
+ */
+export declare function sourceIssue(error: unknown, code: string): Promise<Issue>;
+/**
+ * The outcome a store failure is said by: its code, and for `UNAVAILABLE`
+ * whether the server answered (`unavailable.server`, 「服务端暂时无法处理」)
+ * or nothing came back (`unavailable`, 「无法连接服务端」) — the two send an
+ * operator to different places. A catalogue without the longer key falls
+ * back along the dots.
+ */
+export declare function storeOutcome(error: ViewStoreError): string;
+/**
+ * Why one whole record could not be read (`fetchRecord`): refused to this
+ * reader — the source answered 401 or 403 — or failed, in the source's own
+ * words either way. A refusal is its own sentence because it is the one a
+ * reader cannot fix by trying again: a link to a record of another tenant
+ * says so, rather than "could not be read".
+ */
+export declare function recordReadIssue(error: unknown): Promise<Issue>;
+//# sourceMappingURL=issues.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"issues.d.ts","sourceRoot":"","sources":["../../src/runtime/issues.ts"],"names":[],"mappings":"AAcA,OAAO,EAEL,KAAK,KAAK,EACV,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAI3B;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,CAE3D;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,KAAK,CAAC,CAKhB;AAgBD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAK1D;AAQD;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAKpE"}

package/dist/runtime/listeners.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Who is subscribed, and how they are told — the half of a store that is the
+ * same wherever one is written.
+ *
+ * Every store in this package has the shape `useSyncExternalStore` asks of
+ * one: `subscribe` returns the way to stop listening, and a change notifies
+ * whoever is still listening. Four of them wrote that out by hand — the two
+ * runtimes, the list-change notifications and the countdown React reads a
+ * refresh off — and each copy carried the same two rules in a comment of its
+ * own: notify **after** the new state is committed, and walk a **copy** of
+ * the set, so a listener that unsubscribes from inside its call does not
+ * decide who else hears this one.
+ *
+ * A factory rather than a class, because a store hands `subscribe` over as a
+ * bare function: `useSyncExternalStore(store.subscribe, …)` calls it with no
+ * receiver, which a method reading `this.listeners` does not survive.
+ */
+export interface Listeners<A extends unknown[] = []> {
+    /** Starts listening; the returned function stops. */
+    subscribe(listener: (...args: A) => void): () => void;
+    /** Tells everyone listening, over a copy of the set. */
+    emit(...args: A): void;
+    /** Forgets everyone, so a disposed store leaves no listener behind. */
+    clear(): void;
+}
+export declare function listenerSet<A extends unknown[] = []>(
+/**
+ * What to do with a listener that throws. Left out, the throw is the
+ * caller's, which is what a store whose `emit` is a render's own business
+ * wants; given, every listener is heard from whatever the ones before it
+ * did — the shape needed where notifying happens inside a write that has
+ * already landed, and where letting the throw out would report a confirmed
+ * write as one to retry.
+ */
+contain?: (error: unknown) => void): Listeners<A>;
+//# sourceMappingURL=listeners.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listeners.d.ts","sourceRoot":"","sources":["../../src/runtime/listeners.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE;IACjD,qDAAqD;IACrD,SAAS,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACtD,wDAAwD;IACxD,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACvB,uEAAuE;IACvE,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE;AAClD;;;;;;;GAOG;AACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,SAAS,CAAC,CAAC,CAAC,CA0Bd"}

package/dist/runtime/navigation.d.ts

@@ -0,0 +1,139 @@
+import { AnalysisViewConfig, DashboardFilters, FilterNode, FilterTree, RecordViewConfig, ViewConfig, ViewDefinition } from '../model/index.js';
+/**
+ * What a name 「{subject} · {group}」 claims (D20 追问): the conditions that
+ * select the group, and what the view is without them. While every one of
+ * `conditions` still narrows the view (`narrowsTo`) the name stands; once
+ * one is taken off, edited or negated, the view goes by `subject` — a name
+ * that still said the group would say what the view no longer shows.
+ */
+export interface GroupNaming {
+    /**
+     * What the view is, the group aside: the definition's name for its
+     * records, or the name of the question it was opened from.
+     */
+    subject: string;
+    /** The group's own conditions, as the view opened with them. */
+    conditions: readonly FilterNode[];
+}
+/**
+ * The board a view was opened from (D26 Q33): what 「返回〈仪表盘〉」 names,
+ * and where it goes — the board on the tab and under the filters it was
+ * left on. The workbench draws the way back; the host only routes `back`.
+ */
+export interface BoardOrigin {
+    title: string;
+    back: DashboardTarget;
+}
+/**
+ * What a view takes with it when it leaves a board (D26 Q30), in its own
+ * field names — the same two parts through every way off it:
+ * 「在工作台中打开」, a click's view destination, the follow-up menu and a
+ * board's own analysis.
+ */
+export interface HandOver {
+    /**
+     * What is not the reader's: the board's fixed scope (`fixed`, D26 Q31)
+     * and what the page holds — an embed's locked and hidden filters, or an
+     * embedded view's `scopeFilter`. The opened view runs under it as its
+     * scope — on the applied bar, and nobody's to take off there (H4).
+     */
+    scopeFilter: FilterTree | null;
+    /**
+     * What the reader set on the board: the opened view's own conditions,
+     * which the reader can take off one by one.
+     */
+    filter: FilterTree | null;
+    /** The board it left, for the way back; absent for a board never saved. */
+    from?: BoardOrigin;
+}
+/**
+ * A saved record or analysis view, opened on its own conditions with
+ * `filter` added to them — so it opens 「已修改」 and 「还原」 takes them
+ * back off — under `scopeFilter` as its scope. A host hands it to
+ * `DataWorkbench`'s `handOver` as it is.
+ */
+export interface SavedViewTarget extends HandOver {
+    kind: 'view';
+    definitionId: string;
+    instanceId: string;
+}
+/**
+ * A view nobody saved: a follow-up on a group — its records, the same
+ * question split by another dimension or of the group alone (D22 H) — or
+ * an analysis the board owns. What the reader set on the board is already
+ * among its conditions, as a view drilled out of another's are; what the
+ * page holds is `scopeFilter`. A host hands it to `DataWorkbench`'s
+ * `handOver` as it is.
+ */
+export interface UnsavedViewTarget {
+    kind: 'unsaved';
+    definitionId: string;
+    title: string;
+    config: RecordViewConfig | AnalysisViewConfig;
+    scopeFilter: FilterTree | null;
+    /** What `title` says of a group pressed, when it names one. */
+    named?: GroupNaming;
+    from?: BoardOrigin;
+}
+/**
+ * A dashboard, opened with `filters` as its reader's values — the host
+ * hands them to `DashboardWorkbench`'s `initialFilters` (or
+ * `OpenOptions.filters`), never into the board's config. Another board a
+ * panel's click opens (D23 Q17: each filter the author mapped holds the
+ * group's value, every other one its default), or the way back to the one
+ * a view left (`BoardOrigin.back`, on the tab it was left on).
+ */
+export interface DashboardTarget {
+    kind: 'dashboard';
+    definitionId: string;
+    instanceId: string;
+    filters: DashboardFilters;
+    /** The tab to open on (`initialTab`); absent, where its reader last read it. */
+    tab?: string | null;
+}
+/** Where a way off the board goes, for the host's route. */
+export type ViewNavigation = SavedViewTarget | UnsavedViewTarget | DashboardTarget
+/** A page of the host's: a panel's URL filled with the group pressed. */
+ | {
+    kind: 'url';
+    url: string;
+};
+/** The two a workbench opens (`DataWorkbench`'s `handOver`). */
+export type ViewHandOver = SavedViewTarget | UnsavedViewTarget;
+/** The conditions of a handed tree, as nodes to AND onto a view's own. */
+export declare function handedConditions(tree: FilterTree | null): FilterNode[];
+/**
+ * A config with what the reader set on a board (`HandOver.filter`) ANDed
+ * onto its own conditions — flattened into one "all of" while its own
+ * were one — and read in the editor's advanced mode once they no longer
+ * are (`drillFilter`). The config itself when nothing was handed.
+ */
+export declare function withHandedFilter<C extends RecordViewConfig | AnalysisViewConfig>(config: C, filter: FilterTree | null): C;
+/**
+ * A condition tree that no longer flattens into one "all of" group is an
+ * advanced one, which is how the editor has to open it.
+ */
+export declare function withFilterMode<C extends RecordViewConfig | AnalysisViewConfig>(config: C): C;
+/**
+ * Whether a handed view's draft still says what the hand-over left it at
+ * (`landed`), whatever object holds it now: what the board added is then
+ * the only difference from the saved view, and going back to the board
+ * restores it there — nothing is lost, so nothing is asked (D26 Q33). A
+ * config is JSON, so equal by value is the same config.
+ */
+export declare function untouchedSince(draft: ViewConfig, landed: ViewConfig | null): boolean;
+/**
+ * Whether a draft differs from its saved config only in how it is looked
+ * at — the sort, the page size, the text in the search box (the root search
+ * on the definition's search field) — and in nothing it asks (R2-39). On a
+ * view the reader cannot save in place, such a draft is a look-up nobody
+ * meant to keep: switching away is not asked about, where a condition built
+ * on it still is, since 「另存为」 is what it was for.
+ */
+export declare function lookedOnly(view: {
+    draft: ViewConfig;
+    saved: {
+        config: ViewConfig;
+    } | null;
+}, definition: ViewDefinition | undefined): boolean;
+//# sourceMappingURL=navigation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../src/runtime/navigation.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,UAAU,EACV,cAAc,EACf,MAAM,mBAAmB,CAAC;AAS3B;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,UAAU,EAAE,SAAS,UAAU,EAAE,CAAC;CACnC;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,eAAe,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;OAKG;IACH,WAAW,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAgB,SAAQ,QAAQ;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,SAAS,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,GAAG,kBAAkB,CAAC;IAC9C,WAAW,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B,+DAA+D;IAC/D,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,gFAAgF;IAChF,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB;AAED,4DAA4D;AAC5D,MAAM,MAAM,cAAc,GACtB,eAAe,GACf,iBAAiB,GACjB,eAAe;AACjB,yEAAyE;GACvE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjC,gEAAgE;AAChE,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,iBAAiB,CAAC;AAE/D,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,UAAU,EAAE,CAGtE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SAAS,gBAAgB,GAAG,kBAAkB,EAC/C,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,CAAC,CAOzC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,gBAAgB,GAAG,kBAAkB,EAC5E,MAAM,EAAE,CAAC,GACR,CAAC,CAIH;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,GAAG,IAAI,GACxB,OAAO,CAET;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI,CAAA;CAAE,EACjE,UAAU,EAAE,cAAc,GAAG,SAAS,GACrC,OAAO,CAkBT"}

package/dist/runtime/openRuntimes.d.ts

@@ -0,0 +1,34 @@
+import { ViewInstance } from '../model/index.js';
+import { ManagedViewRuntime, ViewRuntime } from './viewRuntimeTypes.js';
+export declare class OpenRuntimes {
+    private readonly runtimes;
+    add<R extends ManagedViewRuntime>(runtime: R): R;
+    /** Every open view, the ones disposed behind the engine's back dropped. */
+    all(): ManagedViewRuntime[];
+    /** The runtime a write command may be addressed to: one the engine owns. */
+    require(runtime: ViewRuntime): ManagedViewRuntime;
+    /**
+     * Open runtimes whose baseline is this instance, `first` ahead of the rest.
+     * The engine allows an instance to be open more than once, and a confirmed
+     * write to it concerns each of them.
+     */
+    holders(id: string, first?: ManagedViewRuntime): ManagedViewRuntime[];
+    /**
+     * Closes one open view: disposes it and drops it from the registry.
+     *
+     * A caller that only calls `runtime.dispose()` leaves the engine holding a
+     * dead runtime, which then answers `locate` with a revision nobody can write
+     * against, so this is the way to let one go.
+     */
+    close(runtime: ViewRuntime): void;
+    forget(runtime: ManagedViewRuntime): void;
+    disposeAll(): void;
+    /**
+     * The instance an open view of `id` was last saved as — its saved config,
+     * never its draft — or null when none is open.
+     */
+    saved(id: string): ViewInstance | null;
+    /** Drops runtimes a caller disposed directly, which the registry cannot see. */
+    prune(): void;
+}
+//# sourceMappingURL=openRuntimes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openRuntimes.d.ts","sourceRoot":"","sources":["../../src/runtime/openRuntimes.ts"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAI7E,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiC;IAE1D,GAAG,CAAC,CAAC,SAAS,kBAAkB,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC;IAKhD,2EAA2E;IAC3E,GAAG,IAAI,kBAAkB,EAAE;IAK3B,4EAA4E;IAC5E,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,kBAAkB;IAMjD;;;;OAIG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,EAAE;IAOrE;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAQjC,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAKzC,UAAU,IAAI,IAAI;IAKlB;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAKtC,gFAAgF;IAChF,KAAK,IAAI,IAAI;CAId"}

package/dist/runtime/panelViews.d.ts

@@ -0,0 +1,42 @@
+import { RuntimeLimits, ViewInstance, ViewScope } from '../model/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+import { DefinitionRegistry } from './definitions.js';
+import { PermissionGuard } from './permissions.js';
+import { WriteLedger } from './writeLedger.js';
+/** What saving a panel's view stands on: the engine's own parts. */
+export interface PanelViewsHost {
+    registry: DefinitionRegistry;
+    kinds: FieldKindRegistry;
+    limits: RuntimeLimits;
+    guard: PermissionGuard;
+    ledger: WriteLedger;
+}
+/**
+ * Which view of a panel is saved as a view of its own: the analysis the
+ * board owns (「另存为视图」, D22 C), or the saved view it shows, copied for
+ * another audience (「复制为共享视图并替换」, D22 B).
+ */
+export type PanelViewSource = 'owned' | 'saved';
+/**
+ * A dashboard panel's view saved as a view of its own, the panel pointed at
+ * it (`ViewEngine.saveOwnedView`, `ViewEngine.copyPanelView`): the new
+ * instance is listed with the definition's other views from then on, and
+ * the panel keeps its title, wiring, click and override — it shows the very
+ * same view. The board itself is not written: the panel's new reference is
+ * an edit of its draft, saved with the board like any other.
+ *
+ * A saved view is copied as it was saved — not the panel's look over it,
+ * nor the board's filters, which stay the panel's — and is left as it is.
+ * Judged as any save-as is: the config against its definition, a title,
+ * the right to create at that audience. A panel without that source is
+ * refused (`dashboard.panel.not-owned`, `dashboard.panel.not-referenced`).
+ */
+export declare class PanelViews {
+    private readonly host;
+    constructor(host: PanelViewsHost);
+    save(target: unknown, panelId: string, from: PanelViewSource, input: {
+        title: string;
+        scope: ViewScope;
+    }): Promise<ViewInstance>;
+}
+//# sourceMappingURL=panelViews.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panelViews.d.ts","sourceRoot":"","sources":["../../src/runtime/panelViews.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,aAAa,EAEb,YAAY,EACZ,SAAS,EACV,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAS,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,KAAK,EAAE,iBAAiB,CAAC;IACzB,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,OAAO,CAAC;AAQhD;;;;;;;;;;;;;GAaG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,cAAc;IAE3C,IAAI,CACR,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE,GACzC,OAAO,CAAC,YAAY,CAAC;CAkCzB"}