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

package/dist/runtime/writeLedger.d.ts

@@ -0,0 +1,134 @@
+import { ViewInstance, ViewPreferences } from '../model/index.js';
+import { ViewStore } from '../store/ViewStore.js';
+import { ManagedViewRuntime, ViewRuntime } from './viewRuntimeTypes.js';
+import { ViewChange } from './viewChanges.js';
+import { ReferenceOf } from './publish.js';
+import { WriteHandle, WritePayload, WriteState } from './write.js';
+/** What a write command is addressed to: an open view, or a handle. */
+export type WriteTarget = ViewRuntime | WriteHandle;
+export type ConflictChoice = 'reload' | 'overwrite';
+/** Everything a write can hand back, by action. */
+export type WriteResult = ViewInstance | ViewPreferences | void;
+/**
+ * What the ledger cannot reach on its own.
+ *
+ * A write's outcome belongs to the ledger, but a *confirmed* write also moves
+ * things the ledger does not own: the engine's summary and preference caches,
+ * and the other open views of the same instance. The engine hands those over
+ * as these few calls rather than letting the ledger hold its registry.
+ */
+export interface WriteLedgerHost {
+    /** The port every write goes to. */
+    readonly store: ViewStore;
+    /** Idempotency keys; overridden in tests to keep them readable. */
+    newId?(): string;
+    /** Remembers the summary of an instance the store has just confirmed. */
+    noteInstance(instance: ViewInstance): void;
+    /** Forgets a deleted instance and closes every open view of it, `owner` first. */
+    dropInstance(id: string, owner: ManagedViewRuntime | undefined): void;
+    /** Remembers preferences the store has just confirmed. */
+    notePreferences(definitionId: string, preferences: ViewPreferences): void;
+    /** Re-reads preferences through the host, so its cache moves with them too. */
+    readPreferences(definitionId: string): Promise<ViewPreferences>;
+    /** Open views whose baseline is this instance. */
+    holders(id: string): readonly ManagedViewRuntime[];
+    /**
+     * Says that a confirmed write changed what a definition's list holds. It
+     * hangs off the same place the effects do, so a retry and an overwrite
+     * announce what the first attempt would have.
+     */
+    noteChange(change: ViewChange): void;
+    /** A panel's saved view, read for a board headed for the system views. */
+    referenceOf: ReferenceOf;
+}
+/**
+ * The write ledger: one account of every write that left and has not been
+ * settled, keyed by its `requestId`.
+ *
+ * Every write leaves through `dispatch`, so the default UI and a hand-built
+ * one behave the same, and every non-success outcome lands in the same three
+ * recovery actions: `retryWrite`, `abandonWrite`, `resolveConflict`.
+ *
+ * What the ledger keeps is the *body* of the write rather than the draft it
+ * came from, which is what makes those three honest: a retry and an overwrite
+ * replay the original intent, so what the user asked for survives whatever
+ * they edited while the request was in flight.
+ */
+export declare class WriteLedger {
+    private readonly host;
+    private readonly writes;
+    /** Write targets with a request in flight; see `dispatch`. */
+    private readonly inFlight;
+    private readonly owners;
+    private readonly newId;
+    constructor(host: WriteLedgerHost);
+    /** Writes still waiting for a decision, by handle id. */
+    pendingWrites(): ReadonlyMap<string, WriteState>;
+    /** A new logical write: a fresh `requestId`, then the one path out. */
+    dispatch(payload: WritePayload, runtime: ManagedViewRuntime | undefined): Promise<WriteResult>;
+    /** Replays the original intent under its original `requestId`. */
+    retryWrite(target: WriteTarget): Promise<WriteResult>;
+    /**
+     * Drops the outcome and keeps the draft; a later save is a new intent.
+     *
+     * A conflict told the engine what the store holds now, and that stays
+     * true whatever the reader chose: the cached summary and preferences take
+     * the store's revision, so the next command given only an id — a rename
+     * from the list, a reorder — is not refused against a revision already
+     * known to be gone. An open view keeps its baseline: its draft was written
+     * against that one, and only the reader's choice moves it.
+     */
+    abandonWrite(target: WriteTarget): void;
+    /**
+     * `reload` takes the server's state, losing the draft; `overwrite` replays
+     * the original intent against the revision the conflict reported, which is a
+     * new logical write and so takes a new `requestId`.
+     */
+    resolveConflict(target: WriteTarget, choice: ConflictChoice): Promise<WriteResult>;
+    /**
+     * The one place a write leaves the engine. Success clears the outcome;
+     * anything else is recorded, attached to the owning runtime and raised as a
+     * `ViewWriteError` carrying its own handle.
+     *
+     * It takes the `requestId` rather than minting one, because a retry is the
+     * same logical write and has to carry the key the first attempt used.
+     */
+    private replay;
+    /**
+     * Whether an outcome takes the open view's place for its write. The view's
+     * own writes (a save, a first save, a save as) always do — the latest one
+     * is what the reader is looking at. A write the manager sent through the
+     * view (a rename, a change of audience, a delete) does only where nothing
+     * of the view's own is waiting: a conflict the reader has not resolved yet
+     * is theirs, and a failed rename from the list must not hide it.
+     */
+    private mayShow;
+    /**
+     * What a confirmed write changes. It hangs off the payload rather than the
+     * command, so replaying an intent as a retry or an overwrite advances the
+     * same baseline the first attempt would have.
+     */
+    private applyEffect;
+    /** The actions that hand back an instance say so the same way. */
+    private announce;
+    /** Each action against its own method on the port. */
+    private send;
+    /** How a thrown write becomes an outcome the three recovery actions read. */
+    private toWriteState;
+    /** A store may report a conflict without the state it holds; ask for it. */
+    private fetchRemote;
+    /** The `reload` half of `resolveConflict`: take what the server holds. */
+    private reload;
+    /** The entry a recovery action names, whether by open view or by handle. */
+    private requireWrite;
+    /**
+     * An unknown outcome is a write that may have landed. Sending another to
+     * the same target before it is retried or abandoned is how a first save
+     * ends up as two instances, so a new intent waits; only the replay of the
+     * unknown write itself, under its own `requestId`, goes through.
+     */
+    private requireNoUnknownWrite;
+    /** Closes the account for one write: nothing left to retry or abandon. */
+    private settle;
+}
+//# sourceMappingURL=writeLedger.d.ts.map

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

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

package/dist/shadcn-bridge.css

@@ -0,0 +1,107 @@
+/*
+ * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * The shadcn bridge, an optional entry of its own
+ * (`@ahoo-wang/wow-view-engine/shadcn-bridge.css`, phase 5, D30 Q46).
+ *
+ * A host that already has a shadcn/ui theme — `--background`, `--primary`,
+ * `--radius` and the rest declared on its `:root`, with `.dark` on `<html>`
+ * for its dark values — imports this beside `styles.css`, and every view
+ * wears the host's theme: each preset variable of this package is pointed
+ * at the shadcn token of the same name. The bridge writes the preset layer
+ * (`--fvp-*`, theme-architecture.md 3.2), as a preset does, so the host's own
+ * `--fve-*` are still read first. The value is resolved where it is
+ * declared, on `<html>`, so it is whatever the host's `:root` says in the
+ * mode `<html>` is in; both halves read the same token for that reason.
+ *
+ * Four kinds of token are not bridged (Q46), and keep this package's values
+ * unless the host sets them one by one:
+ *
+ * - `input` and `ring`. A shadcn brand theme commonly writes
+ *   `--input: var(--border)` and `--ring: var(--primary)`: a divider grey
+ *   and a brand colour, neither of which owes the 3:1 that WCAG 1.4.11 asks
+ *   of a control's edge and of a focus mark. Here both are tuned to it.
+ * - The status colours — `destructive` (with its ink), `success`, `warning`.
+ *   They are text on the page as well as fills, measured to 4.5:1 in both
+ *   modes; shadcn has no `success` or `warning` at all.
+ * - The eight chart colours. A shadcn palette has five and often starts on
+ *   red; these are eight, measured for colour-vision distance in both modes.
+ * - What is derived rather than set: `row-hover` and `quiet-foreground` follow
+ *   `muted`, `background` and `foreground`, which are bridged.
+ *
+ * The type is bridged as well — `--fvp-font-sans` from the host's
+ * `--font-sans`, shadcn v4's name — and the shadows are not: shadcn has no
+ * standard name for them.
+ *
+ * **The bridge or a preset, never both** (themes.md 2.8): the bridge applies
+ * only while `<html>` names no preset. Both are weightless and both sit on
+ * `<html>`, so which won used to be whichever file the host imported last; a
+ * host that imports the bridge and still puts `data-fve-preset` on `<html>`
+ * is asking for the preset, and gets it.
+ *
+ * Like the presets, the block is `:where()`, weighing nothing, and it writes
+ * the preset layer: a `--fve-*` the host sets on its own `:root` is read
+ * before it, and a surface pinned to a preset (`preset="neutral"`) empties
+ * the preset layer on itself (`@layer fve-reset` in `styles.css`) and
+ * replaces what the bridge gave it. A shadcn token the host does not declare
+ * leaves its variable unset, so the token falls back to the built-in value.
+ * `scripts/verify-package.mjs` checks the built file: one
+ * `:where(:root:not([data-fve-preset]))` rule, every declaration
+ * `--fvp-[dark-]<token>: var(--<token>)`, and exactly the variables the
+ * registry bridges.
+ */
+:where(:root:not([data-fve-preset])) {
+  --fvp-background: var(--background);
+  --fvp-foreground: var(--foreground);
+  --fvp-card: var(--card);
+  --fvp-card-foreground: var(--card-foreground);
+  --fvp-popover: var(--popover);
+  --fvp-popover-foreground: var(--popover-foreground);
+  --fvp-primary: var(--primary);
+  --fvp-primary-foreground: var(--primary-foreground);
+  --fvp-secondary: var(--secondary);
+  --fvp-secondary-foreground: var(--secondary-foreground);
+  --fvp-muted: var(--muted);
+  --fvp-muted-foreground: var(--muted-foreground);
+  --fvp-accent: var(--accent);
+  --fvp-accent-foreground: var(--accent-foreground);
+  --fvp-sidebar: var(--sidebar);
+  --fvp-sidebar-foreground: var(--sidebar-foreground);
+  --fvp-sidebar-accent: var(--sidebar-accent);
+  --fvp-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --fvp-sidebar-border: var(--sidebar-border);
+  --fvp-border: var(--border);
+  --fvp-radius: var(--radius);
+  --fvp-dark-background: var(--background);
+  --fvp-dark-foreground: var(--foreground);
+  --fvp-dark-card: var(--card);
+  --fvp-dark-card-foreground: var(--card-foreground);
+  --fvp-dark-popover: var(--popover);
+  --fvp-dark-popover-foreground: var(--popover-foreground);
+  --fvp-dark-primary: var(--primary);
+  --fvp-dark-primary-foreground: var(--primary-foreground);
+  --fvp-dark-secondary: var(--secondary);
+  --fvp-dark-secondary-foreground: var(--secondary-foreground);
+  --fvp-dark-muted: var(--muted);
+  --fvp-dark-muted-foreground: var(--muted-foreground);
+  --fvp-dark-accent: var(--accent);
+  --fvp-dark-accent-foreground: var(--accent-foreground);
+  --fvp-dark-sidebar: var(--sidebar);
+  --fvp-dark-sidebar-foreground: var(--sidebar-foreground);
+  --fvp-dark-sidebar-accent: var(--sidebar-accent);
+  --fvp-dark-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --fvp-dark-sidebar-border: var(--sidebar-border);
+  --fvp-dark-border: var(--border);
+  --fvp-font-sans: var(--font-sans);
+}

package/dist/store/MemoryViewStore.d.ts

@@ -0,0 +1,134 @@
+import { ViewAudience, ViewConfig, ViewInstance, ViewInstanceSummary, ViewPreferences } from '../model/index.js';
+import { ViewPermissions, ViewStore, WriteContext } from './ViewStore.js';
+export interface MemoryViewStoreOptions {
+    instances?: ViewInstance[];
+    preferences?: Record<string, ViewPreferences>;
+    permissions?: (definitionId: string) => ViewPermissions;
+    /** Lets an example keep its data across reloads; not a second store. */
+    snapshot?: MemorySnapshot;
+}
+/**
+ * Where a `MemoryViewStore` keeps its state between page loads: the whole
+ * state, read and written as one document, synchronously.
+ *
+ * The store reads it when it is made, again before every write, and again
+ * whenever `subscribe` says another writer changed it, so every write is
+ * checked against what is stored now rather than what this store last saw
+ * (see `MemoryViewStore`). `load` answers `undefined` for nothing readable,
+ * and the store then keeps what it holds.
+ *
+ * `save` throws when the state could not be kept — storage full, blocked,
+ * refused. The store then undoes the write in memory and rejects it with a
+ * `ViewStoreError` (`UNAVAILABLE`), so nobody is told a view was saved that
+ * the next page load will not have.
+ */
+export interface MemorySnapshot {
+    load(): MemoryState | undefined;
+    save(state: MemoryState): void;
+    /** Tells the store that another writer changed the state; answers the unsubscribe. */
+    subscribe?(listener: () => void): () => void;
+}
+export interface MemoryState {
+    instances: ViewInstance[];
+    preferences: Record<string, ViewPreferences>;
+}
+/**
+ * The one implementation this package ships: a synchronous map behind the
+ * port, for tests, examples and query-only use.
+ *
+ * It keeps the two consistency rules honest rather than convenient. A write
+ * with a stale revision conflicts, and a replayed `requestId` returns the
+ * first outcome instead of writing twice, so code written against it behaves
+ * the same against a real backend — as do the port's list order and the
+ * server's limits on a title and a config, which it refuses as the server
+ * does (`INVALID`).
+ *
+ * System views come two ways (D81). One seeded with `scope: 'system'` and
+ * no `stored` is a configured one, as the backend's configuration serves
+ * it: every write to it is refused (`FORBIDDEN`). One created with
+ * `scope: 'system'` — 「发布为系统视图」 — or seeded with `stored: true` is
+ * a stored one: saved, renamed and deleted like a shared view, never moved
+ * to another audience (`FORBIDDEN`). Like the server, the store asks no
+ * permission of its own; `editSystem` is the host's to grant and the
+ * engine's to ask.
+ *
+ * With a snapshot, several stores may share one stored state — two tabs over
+ * one `localStorage`. The rule between them is the backend's: **re-read, then
+ * compare revisions, one instance (or one definition's preferences) at a
+ * time.** Before every write the store reloads the stored state, so a write
+ * merges into what the other writer left — a board created in one tab
+ * survives a reorder in the other, and ids never collide — and a write whose
+ * `revision` the other writer has already moved past is refused as
+ * `CONFLICT`, carrying what is stored, as any stale write is. Nothing is ever
+ * overwritten because this store's copy was old. A write the snapshot could
+ * not keep is undone and rejected as `UNAVAILABLE`: it did not land, so a
+ * retry under the same `requestId` is safe.
+ */
+export declare class MemoryViewStore implements ViewStore {
+    private readonly instances;
+    private readonly preferences;
+    /** Outcome per logical instance write, so a retry is idempotent. */
+    private readonly outcomes;
+    /** The same rule for preferences, whose outcome is no instance. */
+    private readonly preferenceOutcomes;
+    private readonly snapshot?;
+    readonly permissions?: (definitionId: string) => ViewPermissions;
+    private sequence;
+    constructor(options?: MemoryViewStoreOptions);
+    /**
+     * In the port's order: system, shared, personal, each oldest first. The
+     * map keeps insertion order — the order views were created or seeded in,
+     * which a change of audience does not move — and the sort is stable.
+     */
+    list(definitionId: string): Promise<ViewInstanceSummary[]>;
+    get(id: string): Promise<ViewInstance>;
+    create(input: Omit<ViewInstance, 'id' | 'revision'>, context: WriteContext): Promise<ViewInstance>;
+    save(id: string, config: ViewConfig, revision: string, context: WriteContext): Promise<ViewInstance>;
+    rename(id: string, title: string, revision: string, context: WriteContext): Promise<ViewInstance>;
+    /**
+     * The port's in-place audience change: personal and shared swap, the id
+     * and everything else stay. Asked for the audience the view already has,
+     * it answers the view unchanged — no revision spent, nothing written — and
+     * remembers that answer under the `requestId` like any other outcome.
+     * A view a shared (or system) board shows is refused as `INVALID` when it
+     * would become personal, `boards` naming those boards by title. A system
+     * view, stored or not, never moves (`FORBIDDEN`).
+     */
+    changeAudience(id: string, audience: ViewAudience, revision: string, context: WriteContext): Promise<ViewInstance>;
+    delete(id: string, revision: string, context: WriteContext): Promise<void>;
+    getPreferences(definitionId: string): Promise<ViewPreferences>;
+    setPreferences(definitionId: string, preferences: ViewPreferences, context: WriteContext): Promise<ViewPreferences>;
+    /**
+     * One instance write: replay, the refusal of its input (`refused`, as the
+     * server validates a command before it reaches the view), re-read, the
+     * three refusals every instance write shares, then `change`. It may answer
+     * `null` for a write that changes nothing — the view is answered as it is
+     * and the revision is not spent — or a `ViewStoreError` for a refusal of
+     * its own.
+     */
+    private update;
+    /**
+     * The titles of the boards everyone sees that show `id` in a panel — the
+     * reference the dashboard kernel's `coversScope` guards from the board's
+     * side. Read off the stored configs as the untrusted JSON they are: the
+     * store may import nothing but the model.
+     */
+    private sharedBoardsShowing;
+    private expect;
+    private commit;
+    /**
+     * Hands the state to the snapshot. When it could not be kept, the change
+     * just made is undone — memory goes back to what is stored — and the
+     * refusal is answered, so the write rejects rather than being reported as
+     * saved. No outcome is remembered for it, so a retry writes again.
+     */
+    private persist;
+    /**
+     * Takes the stored state as it is now, when there is one to read: before a
+     * write, so the write is checked against it, and when another writer says
+     * it changed. Nothing readable leaves what the store holds as it is.
+     */
+    private reload;
+    private restore;
+}
+//# sourceMappingURL=MemoryViewStore.d.ts.map

package/dist/store/MemoryViewStore.d.ts.map

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

package/dist/store/ViewStore.d.ts

@@ -0,0 +1,116 @@
+import { ViewAudience, ViewConfig, ViewInstance, ViewInstanceSummary, ViewPreferences } from '../model/index.js';
+/**
+ * The only port a backend must satisfy. Its failure type is `ViewStoreError`
+ * from `model`, so both sides of the port speak it.
+ *
+ * Eight methods, and one a store may leave out (`changeAudience`); two
+ * consistency rules: a write carries the revision it expects, and a retry
+ * reuses its `requestId` so the server can recognise the same intent.
+ *
+ * Authorization, visibility filtering and deduplication belong to the server.
+ * `permissions` only drives which buttons a UI enables.
+ */
+export interface ViewStore {
+    /**
+     * The definition's views this user sees, as summaries, **in a fixed
+     * order**: the backend's system views first, as it declares them, then
+     * the shared views, then the user's personal ones, each audience oldest
+     * first (the order they were created in; a view moved to the other
+     * audience keeps its place by age there). With no preferences, the first
+     * of the list is the view that opens by default (`resolveDefault`), so
+     * every store answers the same one.
+     */
+    list(definitionId: string, signal?: AbortSignal): Promise<ViewInstanceSummary[]>;
+    get(id: string, signal?: AbortSignal): Promise<ViewInstance>;
+    /**
+     * Creates a view for the scope `input` names. `scope: 'system'` creates a
+     * **stored system view** (D81) — what 「发布为系统视图」 and 另存为 send
+     * when the host grants `editSystem` — and answers it with `stored: true`;
+     * a store that keeps no system views refuses it (`FORBIDDEN` or
+     * `INVALID`). Publishing is a copy: the view it was made from is not
+     * touched. The engine never sends `stored` itself; the store sets it.
+     */
+    create(input: Omit<ViewInstance, 'id' | 'revision'>, context: WriteContext): Promise<ViewInstance>;
+    save(id: string, config: ViewConfig, revision: string, context: WriteContext): Promise<ViewInstance>;
+    /**
+     * Stores the title trimmed. A title blank once trimmed, or longer than
+     * `MAX_VIEW_TITLE_LENGTH`, is refused as `INVALID` — so is one passed to
+     * `create`, and a config of more than `MAX_VIEW_CONFIG_BYTES` passed to
+     * `create` or `save`. The engine refuses both before sending; the store
+     * keeps them for every other caller.
+     */
+    rename(id: string, title: string, revision: string, context: WriteContext): Promise<ViewInstance>;
+    delete(id: string, revision: string, context: WriteContext): Promise<void>;
+    getPreferences(definitionId: string, signal?: AbortSignal): Promise<ViewPreferences>;
+    setPreferences(definitionId: string, preferences: ViewPreferences, context: WriteContext): Promise<ViewPreferences>;
+    /**
+     * Moves a view to the other audience in place (设为共享／设为个人, D18
+     * item 10): the id stays, so a board that shows it keeps showing it.
+     *
+     * Optional: a store without it has no such entry in the manager, and the
+     * engine refuses the command before anything is sent
+     * (`view.changeAudience.unsupported`). One that has it keeps the rules of
+     * every other instance write — the expected `revision` (`CONFLICT`
+     * carrying `instance`), a replayed `requestId` answering the first
+     * outcome, a system view refused (`FORBIDDEN`) — a stored one too: a
+     * system view never moves audience — a missing one
+     * `NOT_FOUND` — and two of its own:
+     *
+     * - **No change is no write.** Asked for the audience the view already
+     *   has, it answers the view as it is, revision unmoved (after the
+     *   revision check, so a stale one still conflicts).
+     * - **A view a shared board shows stays shared.** Made personal, it would
+     *   be blank on that board for every other reader, so the store refuses
+     *   it as `INVALID` with **`boards`, those boards' titles** as stored (a
+     *   title written as a key stays one): the engine says the refusal in
+     *   its own words around them (`view.changeAudience.invalid.shared-boards`),
+     *   so an adapter whose server answers with ids reads the titles. Only the
+     *   store sees every board.
+     *   Deleting such a view stays allowed (the panel alone breaks).
+     */
+    changeAudience?(id: string, audience: ViewAudience, revision: string, context: WriteContext): Promise<ViewInstance>;
+    /** Synchronous, because the application fetched it before creating the engine. */
+    permissions?(definitionId: string): ViewPermissions;
+}
+/**
+ * One logical write. A retry after a timeout reuses the same `requestId` and
+ * the same payload, which is what lets a server deduplicate it.
+ */
+export interface WriteContext {
+    requestId: string;
+    signal?: AbortSignal;
+}
+/** What the current user may do with one definition's views. */
+export interface ViewPermissions {
+    createPersonal: boolean;
+    createShared: boolean;
+    reorder: boolean;
+    setDefault: boolean;
+    /**
+     * Whether this user edits the definition's **stored** system views
+     * (`stored: true`) and creates new ones (`create({ scope: 'system' })`,
+     * 「发布为系统视图」), D81. **Absent is false** — unlike everything else
+     * here, where silence allows: a system view reaches every user, so only a
+     * host that says so opens it, and `ALLOW_ALL` does not. When true, the
+     * `instance(id)` answer below applies to a stored system view (save,
+     * rename, delete); a system view never moves audience, and one declared
+     * in code or in the backend's configuration stays read-only.
+     */
+    editSystem?: boolean;
+    instance(id: string): InstancePermissions;
+}
+export interface InstancePermissions {
+    save: boolean;
+    rename: boolean;
+    delete: boolean;
+    /**
+     * Whether the view may be moved to the other audience. Absent reads as
+     * allowed — silence is not a refusal, as with the rest — and moving it
+     * also asks the create permission of the audience it goes to
+     * (`createShared` to share it, `createPersonal` to take it back).
+     */
+    changeAudience?: boolean;
+}
+/** An empty preference record, which is what an untouched definition has. */
+export declare function emptyPreferences(): ViewPreferences;
+//# sourceMappingURL=ViewStore.d.ts.map

package/dist/store/ViewStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewStore.d.ts","sourceRoot":"","sources":["../../src/store/ViewStore.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,mBAAmB,EACnB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;OAQG;IACH,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IAClC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC7D;;;;;;;OAOG;IACH,MAAM,CACJ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,UAAU,CAAC,EAC5C,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,YAAY,CAAC,CAAC;IACzB,IAAI,CACF,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,YAAY,CAAC,CAAC;IACzB;;;;;;OAMG;IACH,MAAM,CACJ,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,YAAY,CAAC,CAAC;IACzB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,cAAc,CACZ,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,eAAe,CAAC,CAAC;IAC5B,cAAc,CACZ,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,eAAe,EAC5B,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,eAAe,CAAC,CAAC;IAC5B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,cAAc,CAAC,CACb,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,YAAY,CAAC,CAAC;IACzB,kFAAkF;IAClF,WAAW,CAAC,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,CAAC;CACrD;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,mBAAmB,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,IAAI,eAAe,CAElD"}

package/dist/store/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Persistence is one port with eight methods. A business application
+ * implements it against its own API; this package ships only the in-memory
+ * one, because a view store belongs next to the data it describes, and a
+ * `localStorage` snapshot for it, for development and single-user hosts.
+ */
+export * from './localStorageSnapshot.js';
+export * from './MemoryViewStore.js';
+export * from './ViewStore.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}

package/dist/store/localStorageSnapshot.d.ts

@@ -0,0 +1,65 @@
+import { MemorySnapshot } from './MemoryViewStore.js';
+/**
+ * Where a `localStorageSnapshot` reads and writes. Both are structural, so
+ * this layer names no DOM type, and a test hands in a storage of its own.
+ */
+export interface LocalStorageSnapshotOptions {
+    /**
+     * The storage, asked for at each read and write rather than once, so a
+     * browser that refuses it (private mode, blocked site data) is a refused
+     * read or write rather than a failure to make the store. Defaults to
+     * `globalThis.localStorage`.
+     */
+    storage?: () => {
+        getItem(key: string): string | null;
+        setItem(key: string, value: string): void;
+    };
+    /**
+     * Where another tab's change is announced as a `storage` event. Defaults to
+     * `globalThis` — the window — when it has `addEventListener`; `null` listens
+     * nowhere, and a write still re-reads what is stored first.
+     */
+    events?: {
+        addEventListener(type: 'storage', listener: (event: {
+            key: string | null;
+            storageArea?: unknown;
+        }) => void): void;
+        removeEventListener(type: 'storage', listener: (event: {
+            key: string | null;
+            storageArea?: unknown;
+        }) => void): void;
+    } | null;
+}
+/**
+ * A `MemoryViewStore` snapshot kept in `localStorage` under `key`: the whole
+ * store as one JSON document, `{ instances, preferences }`. For development
+ * and single-user hosts until a real backend holds the views (phase 6); it
+ * is one browser's, not a second store.
+ *
+ * Two things a browser does to such a document are the store's to answer,
+ * and this is the design (decided 2026-09-28):
+ *
+ * - **A write storage refuses is a failed write.** `save` throws what
+ *   `setItem` threw (a full quota, blocked storage), and the store undoes the
+ *   write and rejects it as `UNAVAILABLE` — which the engine reports to the
+ *   environment's `onError` as a `store` failure and the UI shows as a save
+ *   whose outcome needs a retry, the error marked `storage` so the line
+ *   says the browser's storage is full or turned off rather than that the
+ *   result never came back. It never pretends a view was kept.
+ * - **Tabs do not overwrite each other.** The stamps are the revisions the
+ *   stored state already carries, one per instance and one per definition's
+ *   preferences. The store re-reads this document before every write and
+ *   checks the write's revision against it, so a write merges instance by
+ *   instance into what another tab stored, and one based on a revision that
+ *   tab has moved past is a `CONFLICT`, the same flow a stale write in one
+ *   tab already takes. A `storage` event for `key` reloads the store, so
+ *   what another tab saved is listed without waiting for a write.
+ *
+ * A missing, unreadable or malformed document reads as nothing stored — the
+ * store starts empty rather than the page breaking — and the next write
+ * replaces it. The format is `{ instances, preferences }`, the one the
+ * compensation console wrote under `wow-compensation-dashboard:views` before
+ * it moved to the view store server.
+ */
+export declare function localStorageSnapshot(key: string, options?: LocalStorageSnapshotOptions): MemorySnapshot;
+//# sourceMappingURL=localStorageSnapshot.d.ts.map

package/dist/store/localStorageSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localStorageSnapshot.d.ts","sourceRoot":"","sources":["../../src/store/localStorageSnapshot.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,sBAAsB,CAAC;AAExE;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM;QACd,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;QACpC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;KAC3C,CAAC;IACF;;;;OAIG;IACH,MAAM,CAAC,EAAE;QACP,gBAAgB,CACd,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE;YAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,WAAW,CAAC,EAAE,OAAO,CAAA;SAAE,KAAK,IAAI,GACvE,IAAI,CAAC;QACR,mBAAmB,CACjB,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE;YAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,WAAW,CAAC,EAAE,OAAO,CAAA;SAAE,KAAK,IAAI,GACvE,IAAI,CAAC;KACT,GAAG,IAAI,CAAC;CACV;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,2BAAgC,GACxC,cAAc,CA+BhB"}