@issuegraph/store 0.1.0

package/dist/mutation.d.ts

@@ -0,0 +1,83 @@
+/**
+ * What an edit IS, and the states an edge can be drawn in while one is in
+ * flight.
+ *
+ * The two live together because they are the same design decision seen from two
+ * sides: the mutation set is closed so that one user act is one round trip, and
+ * the state set is *orthogonal to edge type* so that a pending `blocked-by` is
+ * still recognisably a `blocked-by`.
+ */
+import type { EdgeId, EdgeKind, IssueRef } from './model.ts';
+/**
+ * The states an edge can carry, from the workspace design's §17b.
+ *
+ * They are orthogonal to each other and to the edge's kind: an edge keeps its
+ * type identity and gains a state as an OVERLAY, so combinations need no new
+ * symbols and a viewer can draw `selected` on top of `pending-write` without a
+ * fifteenth case. A projected edge therefore carries a *list* of states, never
+ * one.
+ *
+ * - `selected` — the only state that is not about a write.
+ * - `pending-write` — drawn optimistically; the order has not re-evaluated yet.
+ * - `invalid` — refused before any write. Never dispatched.
+ * - `failed` — the write was rejected; nothing changed upstream.
+ * - `conflict` — the issue changed upstream mid-edit; both versions are held.
+ */
+export declare const EDGE_STATES: readonly ["selected", "pending-write", "invalid", "failed", "conflict"];
+/** One of the five edge states. */
+export type EdgeState = (typeof EDGE_STATES)[number];
+/** Narrow an arbitrary string to an edge state. */
+export declare function isEdgeState(value: string): value is EdgeState;
+/** Correlates a dispatch with its settlement. Unique within one store. */
+export type MutationId = string;
+/**
+ * An edit, before the store has minted an identity for it.
+ *
+ * Four operations and no more. `retype` and `flip` are their own operations
+ * rather than a delete followed by a create, because the design requires a
+ * retype to be one operation, one round trip and one undo entry — and a flip is
+ * the same argument applied to direction. Composing them would make one user
+ * act produce two dispatches and two order re-evaluations.
+ */
+export type Proposal = {
+    readonly op: 'create';
+    readonly kind: EdgeKind;
+    readonly from: IssueRef;
+    readonly to: IssueRef;
+} | {
+    readonly op: 'delete';
+    readonly edgeId: EdgeId;
+} | {
+    readonly op: 'retype';
+    readonly edgeId: EdgeId;
+    readonly nextKind: EdgeKind;
+} | {
+    readonly op: 'flip';
+    readonly edgeId: EdgeId;
+};
+/** A proposal the store has accepted responsibility for, with its identity. */
+export type Mutation = Proposal & {
+    readonly mutationId: MutationId;
+};
+/** Why an edit was refused before any write was attempted. */
+export interface InvalidReason {
+    /** A stable machine-readable code. A host may key a message off it. */
+    readonly code: InvalidCode;
+    /** A plain sentence, safe to show as the inline reason beside the ghost edge. */
+    readonly message: string;
+}
+/**
+ * The refusals this package can reach.
+ *
+ * `would-cycle` is listed here but is never produced by this package: it is what
+ * an injected guard returns, and it is named so hosts and guards agree on one
+ * code rather than inventing two.
+ *
+ * `guard-failed` is the opposite case — the guard threw, so no verdict was
+ * reached at all. It refuses rather than proceeding, because an unknown verdict
+ * is not permission to write.
+ */
+export declare const INVALID_CODES: readonly ["self-edge", "unknown-issue", "unknown-edge", "duplicate-edge", "unchanged-kind", "symmetric-edge", "would-cycle", "guard-failed"];
+/** A refusal code. */
+export type InvalidCode = (typeof INVALID_CODES)[number];
+//# sourceMappingURL=mutation.d.ts.map

package/dist/mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../src/mutation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,yEAMb,CAAC;AAEZ,mCAAmC;AACnC,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAIrD,mDAAmD;AACnD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,SAAS,CAE7D;AAED,0EAA0E;AAC1E,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAChB;IAAE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAA;CAAE,GAClG;IAAE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,+EAA+E;AAC/E,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAEtE,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,8IASf,CAAC;AAEZ,sBAAsB;AACtB,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/mutation.js

@@ -0,0 +1,58 @@
+/**
+ * What an edit IS, and the states an edge can be drawn in while one is in
+ * flight.
+ *
+ * The two live together because they are the same design decision seen from two
+ * sides: the mutation set is closed so that one user act is one round trip, and
+ * the state set is *orthogonal to edge type* so that a pending `blocked-by` is
+ * still recognisably a `blocked-by`.
+ */
+/**
+ * The states an edge can carry, from the workspace design's §17b.
+ *
+ * They are orthogonal to each other and to the edge's kind: an edge keeps its
+ * type identity and gains a state as an OVERLAY, so combinations need no new
+ * symbols and a viewer can draw `selected` on top of `pending-write` without a
+ * fifteenth case. A projected edge therefore carries a *list* of states, never
+ * one.
+ *
+ * - `selected` — the only state that is not about a write.
+ * - `pending-write` — drawn optimistically; the order has not re-evaluated yet.
+ * - `invalid` — refused before any write. Never dispatched.
+ * - `failed` — the write was rejected; nothing changed upstream.
+ * - `conflict` — the issue changed upstream mid-edit; both versions are held.
+ */
+export const EDGE_STATES = Object.freeze([
+    'selected',
+    'pending-write',
+    'invalid',
+    'failed',
+    'conflict',
+]);
+const EDGE_STATE_SET = new Set(EDGE_STATES);
+/** Narrow an arbitrary string to an edge state. */
+export function isEdgeState(value) {
+    return EDGE_STATE_SET.has(value);
+}
+/**
+ * The refusals this package can reach.
+ *
+ * `would-cycle` is listed here but is never produced by this package: it is what
+ * an injected guard returns, and it is named so hosts and guards agree on one
+ * code rather than inventing two.
+ *
+ * `guard-failed` is the opposite case — the guard threw, so no verdict was
+ * reached at all. It refuses rather than proceeding, because an unknown verdict
+ * is not permission to write.
+ */
+export const INVALID_CODES = Object.freeze([
+    'self-edge',
+    'unknown-issue',
+    'unknown-edge',
+    'duplicate-edge',
+    'unchanged-kind',
+    'symmetric-edge',
+    'would-cycle',
+    'guard-failed',
+]);
+//# sourceMappingURL=mutation.js.map

package/dist/mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.js","sourceRoot":"","sources":["../src/mutation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;IACvC,UAAU;IACV,eAAe;IACf,SAAS;IACT,QAAQ;IACR,UAAU;CACF,CAAC,CAAC;AAKZ,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAS,WAAW,CAAC,CAAC;AAEzE,mDAAmD;AACnD,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,OAAO,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC;AA+BD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC;IACzC,WAAW;IACX,eAAe;IACf,cAAc;IACd,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB;IAChB,aAAa;IACb,cAAc;CACN,CAAC,CAAC"}

package/dist/source.d.ts

@@ -0,0 +1,139 @@
+/**
+ * The ports. Everything the host supplies, and nothing this package implements.
+ *
+ * Three of them, and each exists because the alternative would put something in
+ * the package that cannot be there:
+ *
+ * - {@link DataSource} — auth, network and persistence. A package that fetched
+ *   would be a client for one tracker with a pluggable skin.
+ * - {@link OrderDeriver} — the selection order. Writing one here would make a
+ *   second implementation of the thing the reference packages exist to have one
+ *   of. The store owns *when* the order is recomputed; the deriver owns *what*
+ *   it is.
+ * - {@link EdgeGuard} — refusals that need to see the graph, cycles above all.
+ *   Same reason: the walk belongs with the derivation, not beside it.
+ */
+import type { GraphDocument, IssueRef } from './model.ts';
+import type { InvalidReason, Mutation } from './mutation.ts';
+/**
+ * What the host plugs its tracker in through.
+ *
+ * Two methods, deliberately. Anything an adapter needs beyond them — a token, a
+ * retry policy, a rate limiter, a cache — stays on its own side of this
+ * interface, where the store cannot see it and does not have to model it.
+ *
+ * **The store dispatches once per mutation and never retries on its own.** A
+ * retry is a user act (the `retry` on a failed edge), so an adapter must not
+ * assume an idempotency it has not been given.
+ *
+ * **It also runs ONE AUTHORITATIVE OPERATION AT A TIME**, queueing the rest.
+ * `hydrate` and an `applied` `dispatch` both answer with a full authoritative
+ * document and this interface gives neither a version, so two in flight cannot
+ * be ordered by anything the store can observe: the later answer arriving
+ * first, then the earlier one, silently rolls an edge back out — after which
+ * the order derives from a backlog missing a real relationship. Adding a
+ * version here would push bookkeeping onto every adapter, so the store declines
+ * to create the situation instead. An adapter may therefore assume its
+ * `dispatch` is never re-entered, and never overlapped by a `hydrate`.
+ */
+export interface DataSource {
+    /** The whole document. Called on `hydrate()` and again on `rehydrate()`. */
+    hydrate(): Promise<GraphDocument>;
+    /** Perform one edit. Resolving with an outcome; rejecting is read as `rejected`. */
+    dispatch(mutation: Mutation): Promise<DispatchResult>;
+}
+/**
+ * How a dispatch settled.
+ *
+ * Four arms. `applied` and `unchanged` are both authoritative statements about
+ * the document and both carry one; they differ only in whether this edit caused
+ * the difference, which is what decides whether a change summary is emitted.
+ * Collapsing them would attribute somebody else's movement to this edit;
+ * letting `unchanged` carry nothing left the store unable to act on a perfectly
+ * good answer.
+ */
+export type DispatchResult = {
+    /**
+     * The edit landed. `document` is the AUTHORITATIVE state afterwards, not
+     * a patch and not a slice: a partial answer would need merge rules, and
+     * merge rules are exactly where an optimistic store goes wrong. The
+     * document is small enough to be client-side by construction, so sending
+     * all of it removes the whole class.
+     *
+     * A WHOLE DOCUMENT, ISSUES INCLUDED — not an edge set. When this answered
+     * with edges alone, "what the store holds is newer" was true of edges and
+     * false of issues, so the store's freshness question had two dimensions
+     * and only one of them was tracked: a conflict snapshot skipped as stale
+     * threw away the only copy of the issue updates it carried. One kind of
+     * authoritative answer collapses that back to one question. An adapter
+     * that changed no issues simply returns the ones it holds.
+     */
+    readonly outcome: 'applied';
+    readonly document: GraphDocument;
+} | {
+    /**
+     * The edit changed nothing, and `document` is the AUTHORITATIVE state —
+     * the same contract as `applied`, because this is the same kind of claim.
+     *
+     * It carries one for a reason that is easy to miss: "nothing to do" is
+     * often said precisely BECAUSE the store is out of date. Another client
+     * creates the same edge, this edit arrives, the adapter has nothing to
+     * apply — and a bare `unchanged` would leave the store without an edge
+     * that genuinely exists, ranking a backlog missing a real relationship.
+     *
+     * The store adopts it and re-derives, but emits NO change summary: the
+     * movement, if any, was somebody else's and this edit did not cause it.
+     */
+    readonly outcome: 'unchanged';
+    readonly document: GraphDocument;
+} | {
+    /** The write was refused upstream. Nothing changed there. */
+    readonly outcome: 'rejected';
+    readonly reason: string;
+} | {
+    /**
+     * The issue changed upstream mid-edit, and `upstream` is the authoritative
+     * document as it stood at that moment.
+     *
+     * The store retains it and never merges it into anything. What a host may
+     * then do with it is the README's "Resolving a conflict"; this type says
+     * only what the value is.
+     */
+    readonly outcome: 'conflict';
+    readonly upstream: GraphDocument;
+};
+/** One row of the selection order, as the deriver computed it. */
+export interface OrderRow {
+    readonly ref: IssueRef;
+    /** 0-based position. The rail renders these in ascending order. */
+    readonly rank: number;
+    /** Whether the issue may be started now (§6.2). */
+    readonly ready: boolean;
+    /** Why it may not, in the deriver's own words. Empty when ready. */
+    readonly holdReasons: readonly string[];
+}
+/**
+ * The selection order for a document.
+ *
+ * Required, not defaulted. A store cannot invent an order, and a default would
+ * be the second derivation this port exists to avoid.
+ */
+export type OrderDeriver = (document: GraphDocument) => readonly OrderRow[];
+/** What a guard is shown. Both documents, so it need not recompute either. */
+export interface EdgeGuardContext {
+    readonly mutation: Mutation;
+    /** The landed document, before the edit. */
+    readonly current: GraphDocument;
+    /** The document the edit would produce, if it landed. */
+    readonly next: GraphDocument;
+}
+/**
+ * A refusal that needs the graph — a `blocked-by` that would cycle, above all.
+ *
+ * Optional: the store's own structural refusals run either way, and a host
+ * without a graph-aware guard still cannot create a self-edge or a duplicate.
+ * A guard's refusal is identical in effect to a structural one — the edge is
+ * drawn `invalid` and **is never dispatched**.
+ */
+export type EdgeGuard = (context: EdgeGuardContext) => InvalidReason | undefined;
+//# sourceMappingURL=source.d.ts.map

package/dist/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,UAAU;IACzB,4EAA4E;IAC5E,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAClC,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACvD;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GACtB;IACE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;CAClC,GACD;IACE;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;CAClC,GACD;IACE,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IACE;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;CAClC,CAAC;AAEN,kEAAkE;AAClE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,aAAa,KAAK,SAAS,QAAQ,EAAE,CAAC;AAE5E,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,aAAa,GAAG,SAAS,CAAC"}

package/dist/source.js

@@ -0,0 +1,17 @@
+/**
+ * The ports. Everything the host supplies, and nothing this package implements.
+ *
+ * Three of them, and each exists because the alternative would put something in
+ * the package that cannot be there:
+ *
+ * - {@link DataSource} — auth, network and persistence. A package that fetched
+ *   would be a client for one tracker with a pluggable skin.
+ * - {@link OrderDeriver} — the selection order. Writing one here would make a
+ *   second implementation of the thing the reference packages exist to have one
+ *   of. The store owns *when* the order is recomputed; the deriver owns *what*
+ *   it is.
+ * - {@link EdgeGuard} — refusals that need to see the graph, cycles above all.
+ *   Same reason: the walk belongs with the derivation, not beside it.
+ */
+export {};
+//# sourceMappingURL=source.js.map

package/dist/source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.js","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/store.d.ts

@@ -0,0 +1,120 @@
+/**
+ * The store: the one stateful module, and the only place IO happens.
+ *
+ * Everything it decides is decided by the pure modules beside it — validity,
+ * the write ledger and projection, the order diff. What lives here is the state
+ * itself, the calls into the injected data source, and the notification.
+ *
+ * **The rule the structure exists to enforce:** the selection order is derived
+ * from `landed` and from nothing else. `projected` — the landed document plus
+ * every unsettled edit — is built in one place and is not in scope where the
+ * deriver is called, so an optimistic edge cannot reach the order by anyone
+ * forgetting a filter.
+ */
+import { type EdgeId, type StoredEdge, type StoredIssue } from './model.ts';
+import type { MutationId, Proposal } from './mutation.ts';
+import type { DataSource, EdgeGuard, OrderDeriver, OrderRow } from './source.ts';
+import { type OrderChange } from './change.ts';
+import { type ProjectedEdge, type WriteRecord } from './write.ts';
+/** Where hydration has got to. A failure is a state, not an exception. */
+export type HydrationStatus = 'idle' | 'hydrating' | 'ready' | 'failed';
+/**
+ * Whether the order describes everything the user has done.
+ *
+ * `held` means at least one edit is in flight, so the rows shown are the ones
+ * from before it — held still and labelled, which the design prefers to a
+ * half-computed order the rail cannot vouch for.
+ */
+export type OrderStatus = 'settled' | 'held';
+/** The order, and whether it is currently telling the whole story. */
+export interface OrderView {
+    readonly rows: readonly OrderRow[];
+    readonly status: OrderStatus;
+}
+/** Everything a host renders from. Frozen, and stable while nothing changes. */
+export interface StoreSnapshot {
+    readonly status: HydrationStatus;
+    /**
+     * Why the last load failed, when it did. A failed *rehydrate* sets this while
+     * leaving `status` at `ready`: the previous document is still good, and
+     * reporting the store as unloaded because a refresh blipped would throw away
+     * a working surface.
+     */
+    readonly hydrationError?: string;
+    readonly issues: readonly StoredIssue[];
+    /** What the data source has confirmed. The only input to the order. */
+    readonly landed: readonly StoredEdge[];
+    /** What to draw: `landed` plus every unsettled edit, each carrying its states. */
+    readonly projected: readonly ProjectedEdge[];
+    readonly order: OrderView;
+    /** Edits still carrying a state: pending, invalid, failed or conflicted. */
+    readonly writes: readonly WriteRecord[];
+    /** What the last landed edit did to the order. Cleared only by a call. */
+    readonly lastChange?: OrderChange;
+    /**
+     * Why the order could not be recomputed, when the injected deriver threw.
+     *
+     * `order.rows` is then the last order that WAS derived — stale, and labelled
+     * as such, on the same principle as the held order: a rail that cannot vouch
+     * for a ranking says so rather than showing a half-computed one.
+     */
+    readonly orderError?: string;
+    readonly selection: readonly EdgeId[];
+}
+/** A proposal the store has taken on, and a promise for its settlement. */
+export interface ProposalHandle {
+    readonly mutationId: MutationId;
+    /**
+     * Resolves when this edit stops being `pending` — landed, refused, failed or
+     * conflicted. It never rejects: a failure is a state on the snapshot, and a
+     * host that has to `catch` to find out is a host that can forget to.
+     */
+    readonly settled: Promise<void>;
+}
+/** What the host supplies. Only `source` and `derive` are required. */
+export interface StoreConfig {
+    readonly source: DataSource;
+    /**
+     * The selection order. Required: a store cannot invent an order, and a
+     * default would be a second implementation of one.
+     */
+    readonly derive: OrderDeriver;
+    /** Refusals that need the graph — a `blocked-by` that would cycle. */
+    readonly guard?: EdgeGuard;
+}
+/** The store's public surface. */
+export interface Store {
+    getSnapshot(): StoreSnapshot;
+    subscribe(listener: () => void): () => void;
+    /** Load the document. Safe to call once; use `rehydrate` afterwards. */
+    hydrate(): Promise<void>;
+    /**
+     * Re-read the document from the source, keeping unsettled edits.
+     *
+     * Queued behind anything already in flight, and resolves once it has had its
+     * turn — a refresh that overtook a dispatch could be overwritten by that
+     * dispatch's answer, which was computed before it.
+     */
+    rehydrate(): Promise<void>;
+    /** Propose an edit. Renders immediately; the order does not move yet. */
+    propose(proposal: Proposal): ProposalHandle;
+    /** Re-dispatch an unsettled edit, unchanged, against the document as it stands. */
+    retry(mutationId: MutationId): ProposalHandle;
+    /**
+     * Drop an unsettled edit's overlay. The only call that removes the user's
+     * work, and it adopts nothing. See the README's "Resolving a conflict".
+     */
+    discardMine(mutationId: MutationId): void;
+    /** Set the selected edges. Selection is client state; it writes nothing. */
+    select(edgeIds: readonly EdgeId[]): void;
+    /** Clear the change summary. The only thing that does, besides the next edit. */
+    dismissChange(): void;
+}
+/**
+ * Create a store over one data source.
+ *
+ * Nothing is loaded until `hydrate()` is called, so a host can construct the
+ * store during render and start the load where it wants to.
+ */
+export declare function createStore(config: StoreConfig): Store;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,KAAK,MAAM,EAEX,KAAK,UAAU,EACf,KAAK,WAAW,EAEjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAA2B,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAkB,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjG,OAAO,EAAE,KAAK,WAAW,EAAa,MAAM,aAAa,CAAC;AAE1D,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,WAAW,EAAuB,MAAM,YAAY,CAAC;AAGvF,0EAA0E;AAC1E,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,GAAG,QAAQ,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC;AAE7C,sEAAsE;AACtE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED,gFAAgF;AAChF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,kFAAkF;IAClF,QAAQ,CAAC,SAAS,EAAE,SAAS,aAAa,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED,uEAAuE;AACvE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC5B;AAED,kCAAkC;AAClC,MAAM,WAAW,KAAK;IACpB,WAAW,IAAI,aAAa,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5C,wEAAwE;IACxE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,yEAAyE;IACzE,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,cAAc,CAAC;IAC5C,mFAAmF;IACnF,KAAK,CAAC,UAAU,EAAE,UAAU,GAAG,cAAc,CAAC;IAM9C;;;OAGG;IACH,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1C,4EAA4E;IAC5E,MAAM,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IACzC,iFAAiF;IACjF,aAAa,IAAI,IAAI,CAAC;CACvB;AAqFD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,CAgdtD"}