Session({ id: "p1&quo
on its own host only) or remote (used from any host). An object is one instance of a type, per params. A
facet is a plugin's declarations for one host kind. A plugin is a directory with a package.json. A
reference is what you get when you ask for an object (host.get, self.get, ctx.get). A document is data an object
-stores, changed in transactions; a table holds many records with queries, in the host's store; a derive is a value computed from others; a native is an outside
+stores, changed in transactions; a table holds many records with queries, in the host's store, and a live query keeps some of its rows current; a derive is a value computed from others; a native is an outside
resource an object opens and closes. A registry is an
extension point: one plugin defines it, others contribute. A rollout applies a build to the hosts in order.
@@ -258,6 +258,15 @@ host.serve(NoteStore, (_para
Persisted data lives only in local objects with empty params (one per host and type), so its address never depends
on who asked or with which params; an object with params (a view per project) reads from such a store. Writes go
through the same transactions as documents: a note row and a document can change in one commit.
+A table has no watch of its own. To show rows live (the newest notes in a tab), the object declares a live query
+over its own table, with a limit:
+const newest = self.query(rows, recent, 50); // the 50 newest rows, a value like a document's
+return { newest, add, page }; // a member: tabs watch it and get only the changes
+Chord runs the query before the object goes live, and again in every commit of the object that writes rows, and
+sends what changed. Only the object's own tables: it is their only writer, so its commits are exactly when the rows
+can change, and a commit that writes no such table costs nothing. Each writing commit runs the query once more, at
+most the limit's rows: right for data people edit, wrong for a table written hundreds of times a second (there may be
+dragons; keep what the tab shows in a document the object writes with each change instead). The limit is required.
A derive is a value computed from other values, recomputed whenever they change. It is how an object offers
something it does not store:
const count = self.derive([doc], ([notes]) => notes.items.length); // 0, 1, 2, … as notes are added
@@ -277,7 +286,8 @@ self.onLive(async (ctx) =>
for await (const file of inbox.value.files(ctx.abortSignal)) await importNote(file, ctx);
});
Natives are why some objects restart when their plugin changes: an open connection cannot be moved to new code, so
-Chord closes it and opens it again. Objects without natives are swapped in place.
+Chord closes it and opens it again. Objects without natives are swapped in place. A first read of a table is no
+native: declare it as a live query, not with self.open, or the object restarts at every change of its plugin.
Await what you start in a root or a handler. What is started with a context ends with it. Code outside objects
gets its ctx from host.root(fn, ctx), and that scope seals when fn returns; a handler's context ends when its
caller cancels or its object ends. A change still waiting when its context ends is cancelled before it commits:
diff --git a/packages/chord/docs/plugin-authoring.md b/packages/chord/docs/plugin-authoring.md
index 1598dcbe1..ebf6e3271 100644
--- a/packages/chord/docs/plugin-authoring.md
+++ b/packages/chord/docs/plugin-authoring.md
@@ -64,6 +64,27 @@ A facet only declares (`host.serve`, `self.contribute`, `host.references`), sync
happens in objects: state in documents and tables, standing behaviour in a `local` object with empty params (it lives
as long as the host). Names are prefixed by the plugin (`bob.stats`).
+## Tables shown live
+
+A table has no watch. To show its rows live, the object owning it declares a live query with a limit:
+
+```ts
+host.serve(Store, (_params, self) => { // a local type with empty params: it may have tables
+ const items = self.table(Items);
+ const newest = self.query(items, query(Items).orderBy((i) => i.id, "desc"), 50);
+ return { items: newest, add: async (row, ctx) => self.tx(async (tx) => tx.put(items, row), ctx) };
+});
+```
+
+- Chord runs it before the object goes live and again in each commit of the object that writes the table; watchers get
+ only what changed. A commit writing no such table runs nothing.
+- Only the object's own tables, the query fixed for the object's attempt (decide it from params), the limit required
+ (`invalid/args` without one).
+- One query per writing commit, at most `limit` rows (for 100 rows about 60 µs more per commit, 80 µs when watched;
+ `benchmarks.md`): there may be dragons for a table written hundreds of times a second. Keep a document for those.
+- Never read a table in `self.open` to fill a window: that makes a native, and the object restarts at every reload of
+ its plugin instead of swapping in place. A live query is no native.
+
## What a plugin may import
| Import | Resolves to |
@@ -209,5 +230,6 @@ of plugins it has no files of, it declares again, as `Notes` above.
3. Imports: the app's API at one version, own files, same-root contract files by relative path, other repositories'
by package name pinned in `dependencies`.
4. Contracts prefixed with the plugin's name; a version bump for every change of shape.
-5. Files of one kind named `*..ts(x)`.
-6. A test with `testPlugin` and stubs for every name `t.unserved()` lists.
+5. Live rows of a table through `self.query(table, q, limit)`, never a read in `self.open`.
+6. Files of one kind named `*..ts(x)`.
+7. A test with `testPlugin` and stubs for every name `t.unserved()` lists.
diff --git a/packages/chord/docs/slices.md b/packages/chord/docs/slices.md
index 98cb152c5..1c0636a4e 100644
--- a/packages/chord/docs/slices.md
+++ b/packages/chord/docs/slices.md
@@ -44,6 +44,8 @@ slice spec's section citations are for orientation, not a reading limit (owner,
- **Slice 11** (committed 2026-11-03, `slice-11.md`): `src/surfaces/` (scripts objects, registered scripts, the
connection loop, clients, themes), `src/web/`, `src/react/`, `src/tui/`, `src/node/surfaces/`, `src/node/tui/` (the
launcher and its child-process sandbox); examples 56-59.
+- **Live queries** (built 2026-11-03, decision "Live queries over an object's own tables"): `self.query` in
+ `src/store/live-query.ts`; examples 59 and 61 use it; `test/bench/live-query.ts`.
- **Chord's shared code** (upstream pi): `src/watch.ts` (`Watch`, `NativeWatch`, `WatchHandle`, `WatchEnd`,
`NativeWatchable`), Delta (`track`, `diffRevisions`, `applyImmutable`, encoders, `PendingOps`, `appendText`),
context, JSON, output, SQLite drivers.
@@ -136,6 +138,7 @@ pattern, no code. Decided cuts are noted where they apply.
| 11 | `Watchable`, watches (Chord's `Watch`), the batch (W1), reentrancy | 1 |
| 11 | `NativeWatchable`, `self.writable` | 8 |
| 11 | Durable's views as sources (`self.follow` over Durable's `observeXXX`) | 6b |
+| 11 | live queries (`self.query(table, q, limit)`: run before live, re-run per touching commit, diffed) | after 11 |
| 12 | `self.derive`, failures per member, lazy when unwatched, `mapShared` | 1 |
| 12 | container-width benchmark (R24) | 9 |
| 13 | `self.open`, close reasons, order, restart patterns (R16) | 2 (restarts on reload: 7b) |
@@ -193,12 +196,14 @@ deleted (the slice's spec and code are the record). Moved here from `carry-over.
- **`rebuild` of tables** (key and column-type changes): `evolveTable` has no edit for them; build one only when a
real case needs it. (Slice 6a's second spec review; out of slice 7b's scope, `slice-7b.md` §12.)
+### Later: live queries (when a case needs it)
+
+- **Incremental maintenance of a live query's result** (decision "Live queries over an object's own tables"): an
+ ordered, limited result kept from row-level changes in memory, re-running only when a removal empties the window
+ or a bulk write hides which rows changed; today every touching commit re-runs the query. (Live queries build.)
+
### After slice 11
-- **Live queries** (decision "Live queries over an object's own tables"): `self.query(table, q)`, re-run per
- touching commit and diffed; tests (activation before live, swap on reload, a commit not touching the table costs
- nothing, the limit required, cost guard); the tutorial and 59-chat use it instead of `self.open`; the guide's
- section with the warning. Later, when a case needs it: incremental maintenance of an ordered, limited result.
- **Messages and languages in the app kit** (decision "Messages and languages in the app kit", proposal
`docs/i18n/`): `defineMessages`, `t.message`/`t.render`, `MessagesOf`, the `Translations` registry with
fallbacks and conflicts, the locale preference per principal (default from the device, live switch, `lang`/`dir` on
diff --git a/packages/chord/docs/tutorial/book.md b/packages/chord/docs/tutorial/book.md
index 762ae170d..66ee21b52 100644
--- a/packages/chord/docs/tutorial/book.md
+++ b/packages/chord/docs/tutorial/book.md
@@ -70,8 +70,8 @@ without one (a **client**: a page, a terminal). A **link** connects two hosts. A
the app and stamped by links. An **object** is state and methods at one identity; its **contract** (`local` for its own
host only, `remote` for any host) names its **params** (which instance) and members. A remote contract's **variants**
are the member sets different principals get. A **factory** declares an object's parts: **documents** and **tables**
-(stored data, changed in **transactions**), **derives** (values computed from others), **natives** (things opened and
-closed, such as a file or a database cursor). A **reference** is what asking for an object returns. A **facet** is a
+(stored data, changed in **transactions**), **live queries** (a table's rows Chord keeps current), **derives**
+(values computed from others), **natives** (things opened and closed, such as a file or a database cursor). A **reference** is what asking for an object returns. A **facet** is a
plugin's code for one host kind; a **registry** is an extension point plugins **contribute** to. A **rollout** applies
new plugin code to the hosts in order.
@@ -285,7 +285,7 @@ each start. It sits in the URL's fragment, which browsers never send, so it neve
it and receives a session cookie. A command-line client on the same machine reads `owner-token` instead (mode 0600,
chapter III). Nothing is the owner because it comes from loopback: any local process could.
-# A List on Its Own Worker {#worker lede="A host kind, a remote contract, a worker facet with a table and a live window, and the principal that adds a todo."}
+# A List on Its Own Worker {#worker lede="A host kind, a remote contract, a worker facet with a table and a live query, and the principal that adds a todo."}
Each list gets its own process, a **worker**, with its own store: a list that misbehaves cannot take the others down,
and an idle list costs nothing. This chapter declares where lists live, what a list offers, and the worker code that
@@ -376,7 +376,7 @@ const Items = defineTable("todo.items", {
/** The newest todos first. */
const NEWEST = query(Items).orderBy((item) => item.id, "desc");
-/** How many todos the live window holds. */
+/** How many todos the live query holds. */
const WINDOW = 50;
```
@@ -406,40 +406,38 @@ of references. Its factory declares its parts and returns its members:
```ts
host.serve(Store, (_params, self) => {
const items = self.table(Items);
- // The newest todos, oldest first, and the next todo's number: read once when the store goes live, then kept here.
- const window = self.writable([]);
- let next = 1;
- self.open(
- async (ctx) => {
- const { items: newest } = await items.page(NEWEST, WINDOW, ctx);
- window.set([...newest].reverse());
- next = (newest[0]?.id ?? 0) + 1;
- },
- () => {},
- );
+ // The newest todos, live: read before the store goes live, read again after every commit writing the table.
+ const newest = self.query(items, NEWEST, WINDOW);
return {
- items: self.derive([window], ([value]) => value),
+ // Oldest first, as the list shows them.
+ items: self.derive([newest], ([rows]) => [...rows].reverse()),
```
A **factory** is synchronous and only declares; Chord activates the object afterwards. `self.table` declares the
-table. A table has no watch, so the store keeps a **live window** itself: `self.writable` holds the newest 50 todos,
-filled by `self.open`, which runs during activation, and exposed through `self.derive` (a writable is an in-process
-value, not a state member; a derive over it is). `self.open` is meant for **natives**, things opened and closed; the
-window's first read is one, and chapter VIII shows its price.
+table. `self.query(items, NEWEST, WINDOW)` declares a **live query** over it: the rows of `NEWEST`, at most 50, as a
+value the object can expose or derive from. Chord runs it before the store goes live, and again after every commit
+of the store that writes `items`, and sends watchers only what changed. The store's derive turns the rows around,
+oldest first, for the list.
+
+A live query reads only its own object's tables: only the store writes them, so its own commits are exactly the
+moments the rows can change, and a commit that writes no table with a query costs nothing. The limit is required:
+each such commit runs the query once more, at most `WINDOW` rows. That is cheap for a list a person edits and wrong
+for a table written hundreds of times a second (design §11, "there may be dragons").
Writes go through **transactions**: `self.tx(fn, ctx)` runs `fn` with `tx`, and what it stages is committed at once
-when `fn` returns, or not at all if it throws. The window follows after the commit; the store is the table's only
-writer, so it knows every change:
+when `fn` returns, or not at all if it throws. The live query follows in the same commit; the store keeps nothing
+else in memory, not even the next todo's number, which it reads in the transaction:
```ts
add: async ({ text, by }, ctx) => {
// Refused as Chord refuses arguments that fail their schema: the caller gets `invalid/args`.
if (text === "") throw invalid("args", "a todo needs text");
- const item = { id: next++, text, done: false, by, at: Date.now() };
- await self.tx(async (tx) => tx.put(items, item), ctx);
- // In number order: two adds may commit in either order.
- window.set([...window.value, item].sort((a, b) => a.id - b.id).slice(-WINDOW));
+ await self.tx(async (tx) => {
+ // The number after the newest todo's: the store's transactions run one after another.
+ const { items: last } = await tx.page(items, NEWEST, 1);
+ tx.put(items, { id: (last[0]?.id ?? 0) + 1, text, done: false, by, at: Date.now() });
+ }, ctx);
return null;
```
@@ -1057,7 +1055,7 @@ console.log(" ada adds ' ':", refused);
```text
8. lists changed, rolled out to: server, list, web, tui
- on list|groceries: todo.store restarted, todo.todos(groceries) parked
+ on list|groceries: todo.store swapped, todo.todos(groceries) parked
ada adds ' tea ': [ ] tea (ada)
ada adds ' ': { code: 'invalid', reason: 'args' }
```
@@ -1074,9 +1072,21 @@ and rolled it out host by host. On each host Chord stages the new code (it runs
| its new code waits for a dependency | **parked** until the dependency is live |
| its type was removed | **ended**; its holders wait until something serves it again |
-The store opens a native (the window's first read), so it restarted and read its window again from the table; the
-views waited for it (parked), then went on with the new code. Ada's reference never noticed more than a moment of
-`loading`, and her next add was trimmed. Her blank one is now empty after trimming, so the store refused it with
+The store opens no natives, and neither does its new factory: its live query is not a native, Chord runs it. So the
+store was **swapped**, not restarted. The sequence on the list's worker:
+
+1. The store's new attempt starts beside the old one: the same object, instance, table and line. Calls arriving now
+ wait at a gate; calls already running finish on the old code.
+2. The new attempt runs its live query (the same read as at the first activation) and goes live; the gate opens,
+ and references move to its members by name, each with one frame from its last value.
+3. The old attempt is sealed once its calls settled; its query leaves with it, so later commits run only the new one.
+
+The views' new attempts need the store, which was still between steps 1 and 2 when they checked it, so they
+**parked** for that moment and went live with the new code right after. Ada's reference waited a moment, and her next add was trimmed.
+Had the store kept its window as a one-time read in `self.open`, it would count as holding a native and **restart**
+at every reload of its plugin: running calls drained, natives closed and opened again, a new instance.
+
+Ada's blank todo is now empty after trimming, so the store refused it with
`invalid("args", …)` (chapter II): her client got `{ code: "invalid", reason: "args" }`, Chord's own error, which
crossed the worker's link and the server's as it was. Had the edit broken the plugin, that plugin alone would have kept its old code
and the report would name the error.
@@ -1364,14 +1374,11 @@ a tutorial.
`"~kind": "Integer"`, which pi-schema's `int()` lacks, so the key of an `int` key column is typed `string`:
`tx.get(items, { id })` with a number fails `tsc`. The store here uses `updateWhere` with `eq` instead of
`tx.update`.
-- **A one-time read at activation is a native.** The live window over a table needs a first read before the object is
- live; `self.open` is the only place, so the store counts as holding a native and restarts at every reload of its
- plugin, parking its views, though it holds nothing open. Tables have no watch, so every table-backed live view
- repeats this pattern (example 59's chat does too).
-
-Three more, found the same way, are fixed: a reloaded web plugin lost its own React state (now `usePageState`,
+Four more, found the same way, are fixed: a reloaded web plugin lost its own React state (now `usePageState`,
chapter VIII), a plugin's `contract.ts` could not be imported outside builds (the API is now a workspace package,
-chapter I), and plugins could not throw Chord's `invalid` (Chord exports `invalid` and `forbidden`, chapter II).
+chapter I), plugins could not throw Chord's `invalid` (Chord exports `invalid` and `forbidden`, chapter II), and a
+live window over a table needed a one-time read in `self.open`, which made the store restart at every reload of its
+plugin (now `self.query`, a live query Chord runs, chapters II and VIII).
# The App's Files {.appendix}
@@ -1399,7 +1406,7 @@ chapter I), and plugins could not throw Chord's `invalid` (Chord exports `invali
| `startWorker({ api, kinds, onError })` | I | a worker's entry |
| `app.ownerLink()`, `app.ownerTokenFile` | I, III | the owner's sign-in, for a browser and for local clients |
| `hostKind(name, params)`, `remote(name, { version, params, hostAddress, variants })`, `local(name, { version, params, members })` | II | host kinds and contracts |
-| `host.serve(Type, factory)`; factory `self`: `table`, `writable`, `open`, `derive`, `tx`, `get`, `contribute` | II | an object's parts |
+| `host.serve(Type, factory)`; factory `self`: `table`, `query`, `derive`, `tx`, `get`, `contribute` | II | an object's parts |
| `host.root(fn, ctx, { principal })`, `ctx.get(Type, params)` | II | code outside objects, as a principal |
| `invalid(reason, message, details?)`, `forbidden(message, details?)` | II, VIII | Chord's errors, thrown by a plugin |
| `self.contribute(Http, { routes })` | III | routes, denied by default |
diff --git a/packages/chord/docs/tutorial/index.html b/packages/chord/docs/tutorial/index.html
index 9f0f5cae9..39d4c9793 100644
--- a/packages/chord/docs/tutorial/index.html
+++ b/packages/chord/docs/tutorial/index.html
@@ -181,8 +181,8 @@ without one (a client: a page, a terminal). A linkobject is state and methods at one identity; its contract (local for its own
host only, remote for any host) names its params (which instance) and members. A remote contract's variants
are the member sets different principals get. A factory declares an object's parts: documents and tables
-(stored data, changed in transactions), derives (values computed from others), natives (things opened and
-closed, such as a file or a database cursor). A reference is what asking for an object returns. A facet is a
+(stored data, changed in transactions), live queries (a table's rows Chord keeps current), derives
+(values computed from others), natives (things opened and closed, such as a file or a database cursor). A reference is what asking for an object returns. A facet is a
plugin's code for one host kind; a registry is an extension point plugins contribute to. A rollout applies
new plugin code to the hosts in order.
@@ -353,7 +353,7 @@ it and receives a session cookie. A command-line client on the same machine read
chapter III). Nothing is the owner because it comes from loopback: any local process could.
-IIA List on Its Own Worker
A host kind, a remote contract, a worker facet with a table and a live window, and the principal that adds a todo.
+IIA List on Its Own Worker
A host kind, a remote contract, a worker facet with a table and a live query, and the principal that adds a todo.
Each list gets its own process, a worker, with its own store: a list that misbehaves cannot take the others down,
and an idle list costs nothing. This chapter declares where lists live, what a list offers, and the worker code that
keeps its todos.
@@ -425,7 +425,7 @@ worker's store:
/** The newest todos first. */
const NEWEST = query(Items).orderBy((item) => item.id, "desc");
-/** How many todos the live window holds. */
+/** How many todos the live query holds. */
const WINDOW = 50;
A table holds many records with queries and pages; it lives in an object, never in a facet. Persisted data lives only
in local objects with empty params (one per host and type), so its address never depends on who asked (design §9,
@@ -447,35 +447,32 @@ of references. Its factory declares its parts and returns its members:
host.serve(Store, (_params, self) => {
const items = self.table(Items);
- // The newest todos, oldest first, and the next todo's number: read once when the store goes live, then kept here.
- const window = self.writable<Item[]>([]);
- let next = 1;
- self.open(
- async (ctx) => {
- const { items: newest } = await items.page(NEWEST, WINDOW, ctx);
- window.set([...newest].reverse());
- next = (newest[0]?.id ?? 0) + 1;
- },
- () => {},
- );
+ // The newest todos, live: read before the store goes live, read again after every commit writing the table.
+ const newest = self.query(items, NEWEST, WINDOW);
return {
- items: self.derive([window], ([value]) => value),A factory is synchronous and only declares; Chord activates the object afterwards. self.table declares the
-table. A table has no watch, so the store keeps a live window itself: self.writable holds the newest 50 todos,
-filled by self.open, which runs during activation, and exposed through self.derive (a writable is an in-process
-value, not a state member; a derive over it is). self.open is meant for natives, things opened and closed; the
-window's first read is one, and chapter VIII shows its price.
self.query(items, NEWEST, WINDOW) declares a live query over it: the rows of NEWEST, at most 50, as a
+value the object can expose or derive from. Chord runs it before the store goes live, and again after every commit
+of the store that writes items, and sends watchers only what changed. The store's derive turns the rows around,
+oldest first, for the list.
+A live query reads only its own object's tables: only the store writes them, so its own commits are exactly the
+moments the rows can change, and a commit that writes no table with a query costs nothing. The limit is required:
+each such commit runs the query once more, at most WINDOW rows. That is cheap for a list a person edits and wrong
+for a table written hundreds of times a second (design §11, "there may be dragons").
Writes go through transactions: self.tx(fn, ctx) runs fn with tx, and what it stages is committed at once
-when fn returns, or not at all if it throws. The window follows after the commit; the store is the table's only
-writer, so it knows every change:
fn returns, or not at all if it throws. The live query follows in the same commit; the store keeps nothing
+else in memory, not even the next todo's number, which it reads in the transaction:
add: async ({ text, by }, ctx) => {
// Refused as Chord refuses arguments that fail their schema: the caller gets `invalid/args`.
if (text === "") throw invalid("args", "a todo needs text");
- const item = { id: next++, text, done: false, by, at: Date.now() };
- await self.tx(async (tx) => tx.put(items, item), ctx);
- // In number order: two adds may commit in either order.
- window.set([...window.value, item].sort((a, b) => a.id - b.id).slice(-WINDOW));
+ await self.tx(async (tx) => {
+ // The number after the newest todo's: the store's transactions run one after another.
+ const { items: last } = await tx.page(items, NEWEST, 1);
+ tx.put(items, { id: (last[0]?.id ?? 0) + 1, text, done: false, by, at: Date.now() });
+ }, ctx);
return null;A todo without text is refused with The watcher marked invalid("args", …), from the API: the error crosses every link as it is, so a
caller on a page or in a terminal gets { code: "invalid", reason: "args" }, as for arguments that fail the
@@ -959,7 +956,7 @@ console.log(" ada adds ' tea ':
console.log(" ada adds ' ':", refused);
8. lists changed, rolled out to: server, list, web, tui
- on list|groceries: todo.store restarted, todo.todos(groceries) parked
+ on list|groceries: todo.store swapped, todo.todos(groceries) parked
ada adds ' tea ': [ ] tea (ada)
ada adds ' ': { code: 'invalid', reason: 'args' }@todo/lists dirty when the file changed; applyChanges rebuilt it (one esbuild call per facet)
@@ -990,9 +987,20 @@ and rolled it out host by host. On each host Chord stages the new code (it runs
The store opens a native (the window's first read), so it restarted and read its window again from the table; the
-views waited for it (parked), then went on with the new code. Ada's reference never noticed more than a moment of
-loading, and her next add was trimmed. Her blank one is now empty after trimming, so the store refused it with
+
The store opens no natives, and neither does its new factory: its live query is not a native, Chord runs it. So the +store was swapped, not restarted. The sequence on the list's worker:
+The views' new attempts need the store, which was still between steps 1 and 2 when they checked it, so they
+parked for that moment and went live with the new code right after. Ada's reference waited a moment, and her next add was trimmed.
+Had the store kept its window as a one-time read in self.open, it would count as holding a native and restart
+at every reload of its plugin: running calls drained, natives closed and opened again, a new instance.
Ada's blank todo is now empty after trimming, so the store refused it with
invalid("args", …) (chapter II): her client got { code: "invalid", reason: "args" }, Chord's own error, which
crossed the worker's link and the server's as it was. Had the edit broken the plugin, that plugin alone would have kept its old code
and the report would name the error.
KeyOf in src/store/table.ts still tests TypeBox's
"~kind": "Integer", which pi-schema's int() lacks, so the key of an int key column is typed string:
tx.get(items, { id }) with a number fails tsc. The store here uses updateWhere with eq instead of
-tx.update.self.open is the only place, so the store counts as holding a native and restarts at every reload of its
-plugin, parking its views, though it holds nothing open. Tables have no watch, so every table-backed live view
-repeats this pattern (example 59's chat does too).Three more, found the same way, are fixed: a reloaded web plugin lost its own React state (now usePageState,
+tx.update.
+Four more, found the same way, are fixed: a reloaded web plugin lost its own React state (now usePageState,
chapter VIII), a plugin's contract.ts could not be imported outside builds (the API is now a workspace package,
-chapter I), and plugins could not throw Chord's invalid (Chord exports invalid and forbidden, chapter II).
invalid (Chord exports invalid and forbidden, chapter II), and a
+live window over a table needed a one-time read in self.open, which made the store restart at every reload of its
+plugin (now self.query, a live query Chord runs, chapters II and VIII).
+
invalid (Chord
host.serve(Type, factory); factory self: table, writable, open, derive, tx, get, contributehost.serve(Type, factory); factory self: table, query, derive, tx, get, contributeextends RoutineDeclarations
{ /** This object's documents of `definition`, in memory for its life (across its attempts). */ @@ -146,6 +148,18 @@ export interface StoreSelf
extends Self
{
state