Skip to content

docs: tell the local-first story (URLs, Atomic Sync, Flutter, end-to-end guide) - #1552

Merged
joepio merged 112 commits into
developfrom
claude/atomic-server-docs-refresh-jv8w40
Sep 22, 2026
Merged

joepio merged 112 commits into
developfrom
claude/atomic-server-docs-refresh-jv8w40

Conversation

@joepio

@joepio joepio commented Sep 18, 2026

Copy link
Copy Markdown
Member

Related Issues

None. Follows the refactor from HTTP origins to did:ad identifiers and Loro-based sync; the docs narrative had not caught up.

Summary

The spec pages (DIDs, commits, wire protocol) were already current. What was missing was the story around them: the book still read as if AtomicServer were an HTTP database you post commits to. This PR adds the framing pages and an end-to-end guide, and makes modest edits to existing pages. No spec chapter is rewritten.

New pages

  • urls.md (early in the book): every identifier shape (did:ad: resource / agent / commit / blob / node, https://, internal:, atomic://pair, ?drive= hints, HTTP aliases of a DID), who mints it and how it resolves.
  • local-first.md: data ownership as "the bytes are on your device", what the server is for now, and the trade-offs.
  • sync.md: the transport-agnostic sync model with a transport table (WebSocket, Iroh, WebRTC, HTTP fallback, Reticulum planned). websockets.md and browser-peer-sync.md now sit under it as the wire reference and the WebRTC path.
  • flutter.md under Clients / SDKs: the Dart SDK on atomic_lib, its API groups, a minimal flow, comparison with the other clients.
  • local-first-guide/ (Guides): a five-step tutorial from a keypair identity, through a server-less Store and Drive, OPFS persistence, promoting the Drive to an always-on device, to pairing a phone. Every call is one @tomic/lib or the Flutter SDK exposes today; the one step that still needs a checkout (the WASM build) says so.

Edited pages

  • AtomicServer chapter opens on "the always-on device" instead of the feature list.
  • Overview, motivation, when-to-use, Extended index and table (DIDs first, Commits described as the signed envelope rather than the versioning mechanism).
  • js.md and js-lib/store.md: serverUrl is optional, createDrive with localOnly, promoteLocalDrive, sync status, did:ad: subjects in getResource.
  • API page: fetching did:ad: over HTTP, /commits corrected to /commit.
  • DID status line, core concepts Subject field, rust-lib feature list, tooling, personal data store use case, Solid comparison, Astro guide note, roadmap, README realtime bullet.

Planning

  • planning/dart-sdk-package.md: the plan for extracting the Dart SDK from the reference app into a pub.dev package. The extraction itself is a code refactor and is not part of this PR.

Verification

mdbook build (0.5.4, the version CI pins) succeeds and every internal link in the rendered book resolves.

Checklist

  • Add changelog entry linking to issue, describe API changes (docs only, no API change)
  • Add or update tests if needed (not applicable)
  • Update docs if needed

🤖 Generated with Claude Code

https://claude.ai/code/session_018ZmptEWmdz92GXTuP77vrb


Generated by Claude Code

claude and others added 16 commits September 18, 2026 20:54
The docs still read as if AtomicServer were an HTTP origin you post
commits to. This refresh sells what the code now does, without rewriting
the spec pages.

New pages:
- urls.md: one map of every identifier shape (did:ad resource / agent /
  commit / blob / node, https, internal:, atomic://pair, ?drive= hints,
  HTTP aliases of a DID), placed early in the book.
- local-first.md: data ownership as "the bytes are on your device", what
  the server is for now, and the honest trade-offs.
- sync.md: the transport-agnostic sync model (signed commits, Loro,
  version vectors, outbox, rights on every transport) with a transport
  table. websockets.md and browser-peer-sync.md now sit under it as the
  wire-format reference and the WebRTC path.
- flutter.md: the Dart SDK on top of atomic_lib via flutter_rust_bridge,
  its API groups, a minimal flow, and how it compares to the other clients.

Edits: overview, motivation, when-to-use, Extended index and table, DID
status line, API page (fetching did:ad over HTTP, /commit not /commits),
tooling, rust-lib feature list, personal-data-store use case, Subject
field in core concepts, README realtime bullet. Commits are described as
the signed envelope around a write rather than the versioning mechanism.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018ZmptEWmdz92GXTuP77vrb
Second pass on the docs refresh.

- New end-to-end guide "Build a local-first app with @tomic/lib": identity
  from a keypair, Store and Drive with no server, OPFS persistence via the
  WASM client database, promoting the Drive to an always-on device, and
  pairing a phone through the Flutter SDK. Every call is one the library
  exposes today; where a step still needs a checkout (the WASM build) the
  guide says so.
- AtomicServer chapter opens on "the always-on device" instead of on the
  feature list.
- js.md and js-lib/store.md: serverUrl is optional, createDrive with
  localOnly, promoteLocalDrive, sync status, and did:ad subjects in
  getResource; save() no longer described as "commit to the server".
- Solid comparison: local-first device store vs POD, DIDs vs WebID, CRDT
  sync vs document writes.
- Astro guide: note that it is the HTTP path and where the local-first
  guide fits.
- planning/dart-sdk-package.md: the plan for extracting the Dart SDK into a
  pub.dev package, referenced from flutter.md, tooling.md and the roadmap.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018ZmptEWmdz92GXTuP77vrb
* Pin Rust builds and enforce Server/SaaS dependency alignment

* Run trusted CI orchestration directly on Mancave
Six small items from planning/security-audit-2026-09.md (D, C16, F), each
verified against current code and covered by a test, plus the C20
verification recorded in the audit doc.

- CORS: any origin may still read, but Access-Control-Allow-Credentials is
  sent only to origins this server answers for (configured domain, base
  domain tenants, loopback, the desktop webview origins), by the same rule
  RequestContext uses for Host. server/src/cors.rs, gate outside the
  permissive Cors layer.
- Client errors as client errors: ParseError maps to 400, malformed commit
  bodies are parse errors, signature and auth-header failures are typed
  Unauthorized (AtomicError::into_unauthorized) and the server keeps that
  type instead of stringifying it. 400/401 instead of 500, so they no
  longer reach Sentry as crashes.
- C16: the importing flag and import source are a tokio task-local
  (ws_apply::import_scope) instead of process-wide statics; the live push
  loop skips the one peer a change came from via the DbEvent source_id,
  which now also covers COMMIT frames applied for a live peer.
  CommitIngestOpts::suppress_live_echo is removed. The Flutter listener
  reads the event's source_id instead of the flag.
- collections::sort_resources is a total order (missing last, numbers
  numeric with NaN placed, numbers before strings); the old comparator
  panicked sort_by from 21 elements up on Rust 1.81+.
- sync::peer: LIVE_PEERS recovers from a poisoned lock instead of
  unwrapping it.
- /upload answers 400 on a multipart error instead of 200 with a partial
  list.
- Drive-by for the clippy gate on stable 1.94: an unnecessary to_string in
  a lib/src/db/website.rs test, pre-existing on develop.


Claude-Session: https://claude.ai/code/session_01H1U7TNdjwqXKv8MQYproiq

Co-authored-by: Claude <noreply@anthropic.com>
…against develop

#1500 merged on 2026-09-17, so its two e2e handoffs, the website handoff and
the start-server script leave planning/ per the folder's own rules. Their
open items and durable lessons move to the owning plans: the website
follow-ups and the inline-RTE flake diagnosis to website-publishing.md, the
CI-versus-local worker topology to e2e-concurrency.md, the remaining red
specs and the useDriveClass gap to e2e-diagnostic-hygiene.md, the harness
traps (redb lock outliving the socket, desynced compiled i18n catalogs, a
borrowed node_modules, the server-root fetch) to silent-failures.md, and the
two rules every agent needs (.wuchale regeneration, HTTP-200 gating) to
AGENTS.md.

The README's "Biggest gaps" list keeps only open gaps, each checked against
code: the query index dropping rows (ignored test in lib/src/db/test.rs) and
store growth (full snapshot per commit, CLI-only compaction) are added, both
with a PR in flight; the plugin model is on develop since #1500, so only
code-first schemas (#1262) remain PR-bound. Status rows corrected: #1355
(npm job) and #1347 (MCP plan) merged 2026-09-18, #1500 merged, #1498 still
a draft, and the addResource / CommitBuilder counts recounted (0 non-test
call sites in data-browser, 31 non-test references all in browser/lib/src).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H1U7TNdjwqXKv8MQYproiq
)

Adds Db::sync_drive_mappings, list_drive_mappings and managed_alias_hosts so a
control plane that holds no user signing keys can install and reconcile host to
Drive mappings without /bind-drive. Removal is scoped to the hosts a previous
run installed, so the localhost entries and hand-made bindings survive.

Mapping keys are normalized, since the Host header arrives in whatever case the
client sent. A host bound to a missing Drive now 404s instead of falling through
to the store root, which on a multi-tenant node answered one tenant's hostname
with another namespace's content.

--served-domain-suffix makes a server answer for *.<suffix> without taking on
the rest of --base-domain, which would also change how subjects are normalized
on a box that already holds customer data.
…g the edit (#1553)

Datatype tags are now written inside exportLoroDeltaInternal, after the
user's ops are sealed, so a drained commit carries them and undo no
longer steps back into the tag write.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
…er tick (#1554)

Store batches the render-phase local-db cache misses of a tick into a
single getResourcesWithSnapshots call, chunked at 200 subjects, and
shares an in-flight read between duplicate requests for one subject.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
…Array.push through the save scheduler (#1541)

Resource.push and Resource.remove now emit ResourceEvents.LocalChange
like set does, so subscribed hooks re-render; useArray.push goes through
the same save scheduler as the other writes; StoreContext no longer
hands out a phantom Store when a provider is missing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
…ializer (#1542)

Server-managed properties are declared once (server-managed-props.ts)
and derived from that list everywhere, and the OPFS row is written
through a single Resource.toClientDbJsonAd/Store.recordPersistedState
path instead of two hand-rolled serializers that had drifted.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
… survive (#1556)

A destroy is signed into the durable outbox and drained like every other
commit, instead of being POSTed straight to the server, so a delete made
offline (or during a reload) is retried rather than lost. Incoming
updates and local-db hydration skip a subject with a pending destroy.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
… envelope (#1544)

A signed destroy now removes the resource, its Loro snapshot, index and
search rows and its cascade-deleted children in the same redb write that
stores the envelope and commit row, with tombstones recorded only after
that write lands. Malformed destroy commits return an error instead of
panicking the request.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
…e removal is applied (#1561)

recursive_remove no longer announces anything; it collects each removed
subject with its drive. remove_resource and the destroy branch of
apply_commit announce them through Db::emit_destroyed once the removal
has actually landed, so a subscriber never learns of a deletion that
could still roll back.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
…1557)

"Commits cannot be edited" now carries error_code::IMMUTABLE_COMMIT (10)
on both transports, and the client decides whether a terminal drop is
benign from the code, falling back to the legacy message match only when
a response carries no recognised code.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KxExJcGw13DnHknGTMAhXY
…e store, scope DID rows by drive stamp

A drive-scoped, sorted, class-filtered collection query returned fewer
rows than the store held, with nothing to show for it
(planning/silent-failures.md, "A query index silently disagreed with the
data it indexes"). The ignored reproduction
`is_a_encodings_all_match_the_class_constraint` found 2 of 4 rows.

Two causes, both in the read that only this query shape takes:

- Rows whose `isA` read back as a plain `String` were in the index and
  were read, then hidden: the built-in collection class extender did
  `is_a.to_subjects()?` on the value, and `Db::resolve_query_member`
  turned any extender error into "drop the row" — from the page and from
  the count. Class extenders now read `isA` through the same reference
  strings the index uses, and an extender that cannot decide is skipped
  with a `warn!` instead of hiding a row the reader may see.
- Rows whose `isA` was a `String` holding the JSON array (the legacy Loro
  encoding of a `ResourceArray`) were never candidates: the index keyed
  them by the literal `["…"]`, and the matcher rejected them for the same
  reason. `Value::to_reference_index_strings` and `Value::contains_value`
  now read the array's elements from one helper, so index and matcher
  cannot disagree.

What should have shouted now does:

- `Db::check_query_index(&Query)` compares a query's member index with a
  scan of the store and reports the missing and stale subjects
  (`QueryIndexReport`). Used by the tests; a full scan, so not on the
  query path.
- A first build of a filter cross-checks the equality constraints the
  planner did not scan, bounded by the planner's 512-entry scan cap,
  warns with the filter and the subjects it missed, and files them
  (`Db::cross_check_first_build`). The hot path is untouched.

Security audit C17: a DID resource cannot be routed to a drive by its
subject, so every drive's watched filters saw it on commit. The `Db` now
resolves each watched filter's `drive` subject to its drive root
(`filter_drive_roots`, filled in `register_watched_query` and
`populate_watched_queries_cache`) and compares a DID row's `drive` stamp
with that root on the commit path and in the index build. The filter's
identity and encoding are unchanged, which is what broke the first
attempt. A row without a stamp, or a filter whose subject is not stored
here, is not excluded; read rights still apply at query time.

Also: `lib/src/db/website.rs` test — `to_hex().to_string()` is
`clippy::unnecessary_to_owned` on the current toolchain, which fails the
workspace clippy gate on develop; one-line fix so the gate is green.

Tests: the reproduction is un-ignored;
`replicated_rows_reach_a_watched_scoped_sorted_query` (5 rows watched,
17 replicated through the sync import path, 22 from every shape),
`first_build_cross_checks_the_unscanned_constraint`,
`check_query_index_names_missing_and_stale_members`,
`did_rows_stamped_into_another_drive_stay_out_of_a_watched_query`.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H1U7TNdjwqXKv8MQYproiq
…ompaction

Opening the file store now logs its size (on disk and length) and open
duration, a warning above 1 GiB naming `atomic-server compact`, and redb's
`DatabaseStats` breakdown: allocated/leaf/branch pages, stored, metadata
and fragmented bytes, and the reclaimable bytes (on disk minus pages in
use, which is what `compact()` gives back; redb's sparse growth headroom
does not count).

When the file is at least 256 MiB on disk and at least 30% of it is dead,
`Db::init_redb_file` compacts it on the handle it already holds, before
any table is read and before the server listens, logs before/after sizes
and duration, and keeps the outcome in `Tree::PluginMeta`
(`Db::last_compaction`). Any failure is a warning; startup never fails
on it. Not applied to the OPFS or sled backends.

Server flags `--auto-compact` (`ATOMIC_AUTO_COMPACT`, default true),
`--auto-compact-min-mb` (256) and `--auto-compact-min-reclaimable-percent`
(30) build the `CompactionPolicy`; library callers pass one to
`Db::init_redb_file_with_policy`. Documented in the installation guide.

Test: a real redb file churned through the same open path (doubling
overwrites plus throwaway resources deleted mid-file) is compacted on
reopen, gives back most of the measured free space, reads every kept
resource back, keeps the record across the next open, and is left alone
with the policy disabled. Config tests cover the flags.

Also fixes a pre-existing `unnecessary_to_owned` lint in
`db::website` tests so `clippy -D warnings` passes.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H1U7TNdjwqXKv8MQYproiq
Comment thread docs/src/atomic-data-overview.md Resolved
Comment thread docs/src/atomic-data-overview.md Resolved
Comment thread docs/src/atomic-data-overview.md Resolved
Comment thread docs/src/urls.md Resolved
claude and others added 13 commits September 19, 2026 09:10
- URLs and identifiers is Core, not Extended: the pointer now sits in the
  Core paragraph of the overview.
- Tools list leads with Atomic Cloud (atomicserver.eu); self-hosting is one
  line without the docker incantation; the Tauri desktop and mobile apps are
  listed with where to download them.
- urls.md: add localId (a name within a parent, used by imports and plugins
  with the atomic:… namespace convention), the atomic://open deep link next
  to atomic://pair, and a short list of strings that look like identifiers
  but are not (Loro commit origins, old placeholders).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018ZmptEWmdz92GXTuP77vrb
…orks (#1563) (#1566)

View transitions were on by default with only a user opt-out. They are
still broken outside Chromium on desktop: the card-to-page morph blows up
into an overlay on Firefox, and #1563 reports the same on Android.

Flip the setting to opt-in. The stored key is new (`viewTransitionsEnabled`,
default false) rather than a flipped default on `viewTransitionsDisabled`:
that key already holds `false` for anyone who toggled the old checkbox back
off, so reusing it would have left transitions on for exactly the people who
had noticed them misbehaving.

The transition machinery and CSS are untouched, so re-enabling by default is
a one-line change once each browser is verified.

- Settings > Accessibility now reads "Enable page transition animations".
- Playwright config and fixtures seed the new key.
- New test pins both sides of the default in useNavigateWithTransition.


Claude-Session: https://claude.ai/code/session_01Pxhq3hXh8AgAk4NZzNdnkR

Co-authored-by: Claude <noreply@anthropic.com>
The navbar started at the top everywhere. On a phone or tablet that puts
the sidebar toggle, the search button and the context menu out of thumb
reach, which matters more than a navbar that sits in the same place on
every device.

The default now keys on a touch-primary pointer rather than viewport
width: a landscape tablet is as wide as a laptop, and a desktop window
dragged narrow is still mouse-operated. New `isTouchPrimary()` helper,
which `useHover` now shares instead of inlining the same media query.

Only the default changes. `useLocalStorage` falls back to it solely when
the key is absent, so a position picked in Settings is preserved.


Claude-Session: https://claude.ai/code/session_01VT2jpYQ73mPfiueW25ty3y

Co-authored-by: Claude <noreply@anthropic.com>
…1570)

Toasts stack from the bottom right, which is exactly where the navbar
sits when it is at the bottom, so a toast covered the search button and
the context menu. The toast container is now lifted by the navbar's
height in that case; with the navbar at the top nothing changes.

The sidebar's OverlapSpacer goes with it. It added 3.8rem beneath the
App panel below 950px with a bottom navbar, dating from the floating
navbar mode. The overlap it guarded cannot happen: SideBarWrapper's
height is the viewport minus the navbar, so the bar never covers the
sidebar.
Every line is one short clause. Ordered core-first: local-first, then
real-time collaboration and presence, then the things you make with it,
then the platform underneath.

Adds the features that were missing: websites, the kanban / calendar /
dashboard / timer views, table templates, the virtual drive, apps,
plugins and integrations, meetings and canvas. Drops the passkey
recovery line, folds invites into authorization and the serialization
formats into the API line.

docs/src/atomic-server.md carries the same table and is updated with it.
#1546) (#1571)

* Generalize PluginRelease to both runtimes and add Release, Installation and Listing classes

* Expose validate_plugin_zip so publish can check a package before storing it

* Add one host core for sandboxed plugins

One HostCore carries the effective grant (caller, never sudo, bounded by
the installation identity), the fetch policy, secret substitution, the
pinned egress check and a streaming response cap, plus get_config,
get_plugin_agent and commit. commit is refused for proposal-only
(extension world) installations. One shared wasmtime Engine and one
fuel/memory policy keyed by runtime and capability live here too.

* Make the JS StoreHost a thin delegate to HostCore

Reads and queries now go through the shared grant, fetch through the
shared policy, and the runtime uses the shared engine and limits. The
PluginHost trait moves to host_core and is re-exported here.

* Make the wasm class-extender host a thin delegate to HostCore

The host impl only translates WIT types now. The server WIT copy is
synced with atomic-plugin/wit so get-plugin-agent, which the guest SDK
already exposes, is served.

* Install both runtimes through an Installation commit and publish wasip2 releases from zip bytes

* Add the plugin runtime convergence plan for #1546

* Add manifest schemaVersion 2 shared by JS and WASM plugins

One versioned manifest carries runtime, world, entrypoints, capabilities
and network origins. v1 upgrades with defaults and serializes unchanged,
so existing release ids are stable. plugin.json translates at the boundary.
Fixtures under testdata/plugin-manifest are shared with the TS mirror.

* Mirror manifest v2 parsing in @tomic/lib against the shared fixtures

* Document manifest v2 and mark plugin.json as the translated legacy form

* Add Release, Installation and Listing to the browser server ontology

* Add installRelease, publishZipRelease and the install review reader to @tomic/lib

* Publish uploaded zips as releases and install them through the Installation review

* Install Store listings through the Installation review, keeping drafts as a secondary action

* Add the Installation view with pause, revoke and uninstall, and list installations on the drive

* Cover the Installation review screen in the plugin and Store e2e specs

* Fix padding-line lint in the manifest v2 mirror

* Derive plugin resource limits from v2 capabilities for both hosts

* Publish wasip2 releases with a v2 manifest and enforce the Installation grant set

* Serve wasip2 releases and their zip from /plugin-package

* Record every published release as a Release resource and serve private releases to its readers

* Record the plugin convergence implementation checkpoint

* Treat schemaVersion 2 as valid in the app package malformed-release test

* Box the manifest in FetchPolicy to keep the enum small

* browser: remove the legacy Plugin view and zip reader

Legacy Plugin resources are migrated into Installations by the server at
startup, so the browser no longer renders or manages class Plugin:
PluginPage, PluginCard, UpdatePluginButton, useCreatePlugin
(uninstall/update) and the client-side zip reader go. The server validates
the uploaded zip and translates plugin.json, so NewPluginButton no longer
inspects it.

AssignRights, PermissionRow and ConfigReference move under
views/Installation, their only user. PluginPermissions and pluginUtils fold
into a shared CapabilityList (extracted from InstallationReviewDialog) that
also renders the pluginPermissions the server writes on an Installation.
InstallationPage shows the manifest author the server fills in.

* browser: drive plugin list reads Installations only

The drive's plugins property was the legacy Plugin list; every plugin is
an Installation found by class under the drive now.

* lib: drop unused manifest and install exports

resolveManifest/ResolvedManifest had no caller outside its test; the
server resolves defaults, the browser validates and reviews. Also removes
the unused RUNTIME_WASIP2, WORLD_SERVER_EXTENSION and INSTALLATION_STATUSES
constants and un-exports the two helper types nothing imported. The Store
compares against RUNTIME_JS instead of a literal.

* e2e: align plugin spec with the Installation page

* Replace the legacy Plugin install hook with a startup migration and one manifest per plugin

PluginMeta now holds a single unified manifest (JSON-encoded records; legacy
MessagePack records upgrade on read and are translated from plugin.json the
first time the plugin loads). Legacy Plugin + pluginFile resources are rewritten
at startup into active Installations pinned to a Release published from their
zip, keeping subject and on-disk files. Re-activating an already materialized
release no longer re-extracts.

* Replace the KV plugin catalog with Listing resources and collapse the publish paths

A public publish now records a publicly readable Listing at <server>/listings/<id>
next to the Release; /plugin-catalog is a class query over Listings and answers
with the Listing fields plus release URL, id, runtime and world. The three
publish handlers share release::publish_release for recording, listing and
world checks. CatalogEntry and the plugin-catalog/v1 keys are gone; the KV
release store stays as the cache it is.

* Document the Installation-only plugin flow and record the cleanup checkpoint

Docs describe Release, Listing and Installation, the Store and zip-upload
paths that both end in the Installation review, and how legacy Plugin
resources are migrated. The planning checkpoint lists what this cleanup
removed and what is still open.

* Read the flat Listing shape from /plugin-catalog in the Store

* Pin a materialized install to its release id, and make pausing stop a plugin

Two things an Installation got wrong once it was the single install path.

An activation decided it had nothing to materialize by comparing the
installed manifest with the release's. Two releases of one plugin agree on
every manifest field and differ in their package bytes, so repointing an
Installation at a new release skipped the extraction and left the previous
code serving under the new release's id. `PluginMeta` now records the release
whose code is on disk and that is what the check compares; a record from
before the field existed says nothing about the bytes, so it materializes
again. The legacy migration records it too, so it still re-extracts nothing.

`paused` and `draft` did nothing at all. The hook handled `active` and
`revoked` and fell through for the rest, and no runtime path read the status,
so Pause wrote a property while the plugin kept serving its hooks. Pausing
now unregisters the class extender, which is not an uninstall: the files and
`PluginMeta` stay, so resuming re-registers the same agent rather than
minting a new identity. `installation::resolve` refuses anything but
`active`, which stops JS runs, and the startup loader skips extenders whose
Installation is not active, so a pause survives a restart.

The wasip2 install test asserted the old behaviour, that pausing and
resuming leaves the extender registered. It now asserts what pausing is for,
and the 'must not re-extract' case it was really about moved to a config
change, which is where it happens in practice.

* Update an installed plugin in place, rather than uninstalling it first

The Installation page showed its pinned release read-only and the only way
to get newer code onto a drive was Uninstall then install again. That
retires the plugin's agent, so everything it owned stopped being its own,
and a second install of the same namespace and name is refused while the
first one is there.

Uploading a zip on the Installation page now publishes it as a private
release, reviews it through the dialog the Store and the zip upload already
use, and repoints this same resource at it. The subject, the config and the
agent stay; only the release, the grants and the version change, and they
change in one commit, because the server checks the grants against the new
release's manifest and would refuse a release that arrived on its own.

The review dialog takes the wording as a prop and starts its config editor
from the config in use rather than the release default, since for an update
that is what the installer is deciding about. A zip for a different plugin
is refused in the page with the names in the message, ahead of the server
refusing it on the identifier comparison.

* Record the materialized release from the install hook, and cover the encoding

Which release's code is on disk is the Installation's business, not the zip
extractor's, so `activate` writes it after `install_or_update_plugin`
returns rather than passing it down. A failed extraction then leaves no id,
and no id means materialize again, which is the safe direction. It also keeps
that function at seven arguments, so clippy gains nothing new.

`PluginMeta`'s encoding test constructed the struct literally and so did not
compile. It now round-trips the id, and a second test pins the compatibility
that matters: a record written before the field existed reads back as `None`
rather than as some release, and is written out without the key.

* Format the touched browser files with oxfmt

The browser workspace formats with oxfmt, not prettier, and `pnpm lint` runs
`oxfmt --check` in each package. Four files had been written by prettier,
which reformatted them whole, so `lib lint` and `data-browser lint` both
failed on the format check. Running the repo's own formatter over them puts
them back, and the net change against the previous head is once again only
the lines this branch actually adds.

`pnpm run -r lint` now exits 0 across the workspace.
* fix(lib,react): make "destroyed" one fact on the store

Deleting a resource left a "Resource with error" row in the sidebar.

A `parent=` query keeps answering with a destroyed child for a moment: the
answer was computed before the destroy landed, and `Collection.fetchPage`
deliberately races the local index against the server's `/query`. Every reader
of such an answer that had not itself witnessed the delete put the row back,
and that is not cosmetic — rendering the row asks the store for the resource,
which re-creates the entry the destroy had removed and then 404s.

The knowledge that a subject was deleted only ever lived in caches scoped to
one instance: `hasPendingDestroy` (an outbox entry, dropped the moment the
server acks), `Collection._removedSubjects` and `useChildren`'s `removedRef`.
A reader created after the delete — a second view on the same query, a folder
re-expanded — had none of them, which is why the row came back.

The store now owns it, as the in-memory half of the tombstone `removeResource`
already wrote to the local database:

- `Store.isDestroyed` / `clearDestroyed`, backed by an insertion-ordered set
  capped at 10k subjects.
- `Collection` and `useChildren` read it; their own sets are gone. A destroyed
  subject is never a member, whatever state arrives for it, and is kept out of
  `_queriedMembers` so a lifted tombstone can re-admit it.
- `applyIncoming` refuses state for a destroyed subject after the ack as well
  as before it.
- `getResourceLoading` answers for one from the tombstone instead of firing a
  request that can only 404.

Only creating a resource again under the same subject lifts a tombstone
(`newResource`); a stale answer no longer can. That is a behaviour change:
`applyResourceChange` used to treat any matching resource event as a restore,
which is the resurrection this fixes.

* test(data-browser): give the Markdown schema suite its own timeout

fileContentsToTiptapJson awaits a lazily imported collaborative Markdown
schema. Whichever of the two tests in that suite runs first pays the
import cost, which exceeds vitest's 5s default whenever the test threads
are oversubscribed. On the shared runner that is routine: a recent run
reported 243s of import time for 86s of wall time, and the suite timed
out there twice in a row while passing locally every time.

Give the suite the same 60s budget the recovery-enrollment suite already
uses for the same reason.
* Create a drive's plugin schema terms in one round, not nineteen

Asking for a new plugin on a drive that has no plugin schema yet means
waiting for `ensureSchema` to write all nineteen terms of `pluginSchema()`
first, and `ensureAll` saved them one after another. Sixteen properties and
three classes, each its own awaited round trip, is most of the time between
clicking "New plugin" and the page appearing, and it is why
`plugins.spec.ts` "a plugin proposes changes, and nothing is written until
you approve" times out waiting for the New plugin heading on a cold drive.

An earlier pass already batched the orphan lookups; the saves were still
sequential, which is the rest of the wait.

The terms are independent: they write different resources under the same
ontology and none of them reads another's subject, so the order they land
in does not matter. Resolve every spec first, collect the ones that have to
be created, and send those creates together. The ontology's own list is
still assembled in spec order, because that order is what someone reading
the ontology sees.

* Note the plugin schema batching in the browser changelog

* Give the Rust checks container the plugin zip its tests include

`server/src/plugins/plugin.rs` and `server/src/handlers/plugin_release_test.rs`
`include_bytes!` `browser/e2e/tests/fixtures/test-plugin.zip`, but
`rustChecksContainer` mounts only the crate directories and `testdata`, so
`/code/browser` does not exist and both test targets fail to compile:

    error: couldn't read `server/src/handlers/../../../browser/e2e/tests/fixtures/test-plugin.zip`

Mount the one file. Nothing else under `browser/` belongs in that container,
and mounting the tree would make every front-end edit invalidate the Rust
layer. This is the same treatment `testdata/pairing-request.json` already gets
a few lines above, for the same reason: a fixture both the Rust and the
JavaScript side test against.

The two call sites are behind `cfg(all(test, feature = "wasm-plugins"))`, so
only the checks container needs it; the build containers are unaffected.
* Stop filing every server error in Sentry twice

Two things reported the same failure. `sentry_actix` captures a handler's
5xx with the request attached, and `tracing_actix_web` separately logs
"Error encountered while processing the incoming HTTP request" at `error!`,
which the Sentry tracing layer turned into a second event.

The staging floods of September showed it plainly: the issue groups pair
up, 6313 events on one side and 6312 on the other, for the same two
incidents. On a free-tier quota that is half the budget spent on duplicates.

Give the tracing layer an event filter that ignores the `tracing_actix_web`
target and delegates everything else to `default_event_filter`, so
background work still reports as before. The log line is untouched; only
the duplicate report goes away.

Also stop the data-browser reporting from a dev server. Vite's hot reload
throws while swapping modules ("_s is not a function", "Cannot access X
before initialization", all with `@react-refresh` frames), which is not a
defect in anything shipped, and those arrived rated above every real bug in
the backlog. Setting VITE_SENTRY_ENVIRONMENT still reports from a local
build on purpose.

* Add changelog entries for the Sentry reporting fixes
Updated video link to a private user image.
* Tell people the assistant can build apps and websites

Before: the new-resource page listed tables, documents, dashboards and the
rest, but nothing on it said apps or websites were possible. Both classes are
minted per drive, so they only appear under "Your resource types" once the
drive already has one — which never happens to someone who was never told.

After: a row of suggestions sits under the AI composer. Clicking one puts a
half-written request in the composer with the caret at the end, so the user
finishes the sentence instead of sending "build me an app" and being asked
what they meant. The row hides once they write their own words, because
setting a textarea from code does not go on the browser's undo stack.

How: AI_BUILD_SUGGESTIONS in the creation catalog, rendered as a gradient-
bordered row in NewRoute under the composer. Unit tests cover the seeds and
the hide rule; an e2e test covers clicking, swapping and hiding.

* Honour "Enable AI Features" on the new-resource page

Before: unchecking Enable AI Features hid the navbar button and the AI chat
entry, but left the whole "Build with AI" composer and the Ask AI button in
the search field on the page. Submitting either one silently ticked the
setting back on, so the only way to get rid of the composer was to not press
it.

After: the composer, its suggestions and the Ask AI shortcut are gone while
the setting is off, and nothing turns it back on behind the user's back. The
blank buttons, templates and upload area stay, since none of them are AI
features. The no-matches line stops offering the assistant too.

How: the section and the Ask AI button render on enableAI, and both
setEnableAI(true) calls are dropped now that nothing reaching the assistant
is rendered while it is off. An e2e test sets the stored setting and checks
what remains.

* Make the build suggestions look like the class buttons

Before: the suggestions were pills with a sparkle icon and labels written as
"An app", "A website". They read as a different kind of control from the
blank class buttons right below them, which they are not.

After: App, Website, Dashboard, Custom table, on the same button as the blank
ones, with a faint rainbow border in place of the grey one. The border comes
up to full colour on hover, focus and while a suggestion is in the composer,
so it still reads as the assistant's row rather than a second Start blank.

How: Suggestion extends BasicChoice and paints its border with a two-layer
background-image, so the geometry can never drift from the blank buttons.
The sparkle is gone.

* Give the build suggestions their class icons

Before: the suggestions were the only buttons on the page with a bare label.
Next to a row of blank buttons that each carry their class's icon, they read
as a different kind of thing.

After: each one wears the icon of the class it makes. Dashboard and Custom
table take theirs from the class subject, so they are literally the same icon
as the blank Dashboard and Table buttons. Website takes the globe already
mapped to website-project. App gets the launcher grid, added to the icon map
so an app shows the same glyph wherever it appears.

How: a suggestion names either a class subject or a drive-minted class
shortname, and the row resolves it through getIconForClass like every other
class button does. The puzzle piece a new app carries as its placeholder
emoji was the obvious choice for App and is deliberately not used: plugins
and installations already have it, and an app sits beside both.
A publish refused for claiming the wrong world had already stored the
package bytes and cached the release record: the check ran in the handler,
after `release::publish_package` had written both. The claim now goes into
that function, which asks straight after reading the manifest and before the
first write, so a refusal leaves nothing on the node. `expect_world` reads
the world from the manifest rather than from the release, because at that
point there is no release to read it from.

`installation_grants` fell back to the capabilities the manifest declares
whenever any step of finding the Installation's approved grants failed. That
is the one direction a fallback must not take: the declared set is what the
plugin asked for, so a lookup going wrong rewarded asking for more than was
approved. Only the absence of an Installation, which is a legacy draft that
never had grants, still reads the manifest. An Installation that cannot be
read, or whose grants cannot be, now grants nothing and logs why. The class
check also went through `Value::to_subjects`, which errors on the scalar
`isA` encodings, so an encoding alone could hand over the declared set;
`Resource::class_subjects` and `Resource::has_class` are now the one
encoding-tolerant reader, shared with `ClassExtender`.

An Installation's `release` is declared an atomicURL and held bare `blake3:`
ids, which meant every writer set it with datatype validation switched off.
Every publish records a `Release` resource and the response carries its
subject; the browser's two zip paths were throwing that away and storing the
id. `publishZipRelease` returns `subject` and the callers pass it, so the
property holds what it is declared to hold and nothing skips validation.
`release::resolve` still accepts a bare id, because Installations written
before this carry one and have to keep working.

One consequence worth knowing: an Installation whose `release` is a URL is
resolved with a read check that a bare id skipped. `/releases/<id>` is keyed
on the content hash but parented to whichever drive published first, so an
agent publishing byte-identical bytes on a second drive gets the first
drive's Release resource back and may not be able to read it. They now get a
rights error at install time rather than installing from a record they
cannot see. That a content-addressed subject is parented to one drive is a
deeper wart, left alone here.
)

A browser keeps its authentication proof in the `atomic_session` cookie.
`setCookieAuthentication` signed one proof and stored it for a day, and
`checkAuthenticationCookie` only asked whether a cookie existed, so nothing
ever re-signed it. Since `AUTH_MAX_AGE_MS` landed in 0.41 the server refuses
a proof older than five minutes, which made a stale proof the ordinary state
of any tab left open, and every request such a tab made was answered 401 --
public ones included.

On staging one tab polling the public `GET /server` endpoint produced 4,215
rejections in a row, every one of them carrying the same `signed at`
timestamp while the server's clock walked past the window.

Two halves:

- The browser refreshes before it goes stale. The cookie now lives no longer
  than the proof it carries, and the freshness check reads the signed
  timestamp out of the cookie instead of only looking for the cookie's
  presence, so the request path installs a fresh proof well inside the
  window.

- The server treats an aged-out proof as no proof. An HTTP request, and the
  headers a socket is opened with, did not ask to be authenticated; a proof
  that has expired says the caller *was* this agent and is no longer, which
  is not by itself a reason to refuse. They continue as the public agent and
  the rights check decides. A signature that does not verify is still
  refused outright, and so is a stale proof in an `AUTH` frame or a peer
  handshake, where the caller asked to be authenticated and is owed the
  answer.
joepio and others added 26 commits September 21, 2026 20:23
dashboard.spec.ts:534 has failed on develop since run 4279, always at the same
line: `locator.fill: Timeout 10000ms exceeded` waiting for `block-name`. It
reproduced here under four-worker load, which it had not done earlier in the
day.

The dialog that fill is waiting for is behind `addBlock`'s two sequential
commits, the Block resource and then the dashboard's block list, before
`setConfiguring` mounts it. Timed inside the spec under that load it took 4.9s
and 11.3s. The ceiling is `use.actionTimeout`, 10s, which is why the same line
fails on a loaded box and passes on a quiet one.

`:469` waits for the config dialog to close after a save, which is the same
round trip. It measured 6.8s and 8.1s against the same 10s: passing, with less
than two seconds to spare, and the same bug waiting its turn.

Both now get 30s, which is what the other write-then-read-back waits in this
suite carry. The test budget is untouched and did not need touching: the
describe is `test.slow()`, so these run on 180s and finish in 30-36s. `:510`
is left alone, since it opens the dialog on an existing block and commits
nothing.

Validated 2 of 2 each under the load that reproduced the failure, at 28.7s and
30.8s for :534 and 35.8s and 31.6s for :469.
`plugin.spec.ts:26` was red from run 4194 and survived three fixes, all of
which aimed at an HTTP fetch rather than at the reason there was one. Two of
them left workarounds behind: this flag, and the `/etc/hosts` line below it.
`f67935b` gave the server its own `ATOMIC_DOMAIN` so it reads its own subjects
locally instead of fetching them, and said both should go once a run was green.

That run is in. Shard 3 of 4326 reported `3 failed, 1 flaky, 2 skipped,
67 passed`, and the three failures are `onboarding:13`, `plugins:31` and
`plugins:164`, with `plugins:110` flaky. `plugin.spec:26`, `mt940:16` and
`installation-recovery:96` are all on that shard and none of them is in the
list.

Only the flag goes. The hosts line has a wider scope and stays, with a comment
that now says what depends on it rather than what used to.

`ATOMIC_ALLOW_PRIVATE_FETCH` does not gate subject fetches, which is worth
recording because the comment being deleted implies it does. `fetch_resource`
(lib/src/client/helpers.rs:205) goes through `fetch_body` (:310) on a plain
`http_client_builder()` with no preflight and no `PublicOnlyResolver`. The
guard is wired only into `untrusted_client_for` (:377), reached from
`fetch_body_untrusted` and `fetch_bytes_untrusted`, and those have five call
sites in the whole tree: `plugins/importer.rs:67`, `plugins/bookmark.rs:119`,
and `plugins/release.rs` `:125`, `:154` and `:215`. `egress::refuse_url`
(plugins/egress.rs:141) never reads the flag, so the plugin host is not a
second route into it, and `for_run` hardcodes `remote_reads: false`
(plugins/host_core.rs:490), so only a class extender with declared
`network.origins` could reach the remote path at all. browser/e2e declares
none, and its one untrusted fetch, the bookmark spec, targets a public name.

So the release machinery was the only path in the suite that could reach the
guard, and it is exactly the path the domain fix stops exercising. Removing
the flag puts the guard back where it protects something: `resolve_public` and
`resolver_rejects_loopback_domain` in lib/src/client/helpers.rs are deliberate,
asserted behaviour that this flag was switching off for every e2e run.

Worth watching once, since no `:26` verdict covers it: `release::file_bytes`
(plugins/release.rs:204) returns early on `internalId`, so a File on this node
that carries only a `downloadURL` still reaches the guarded fetch at `:215`.
Nothing in the suite appears to create one.

Verification: `.dagger` regression tests 4 of 4.
`onboarding.spec.ts:13` failed all three attempts on develop run 4326, at the
`'This is your account'` heading. It passes here alone in 16.7s and fails under
four-worker load, so "identical on every attempt" meant the failure mode was
stable, not that contention was irrelevant: three attempts inside one loaded
shard sample the same conditions three times.

Timed step by step under that load, three copies:

  step                              budget   run A    run B    run C
  profile-name heading                10s      86ms     35ms     42ms
  creating-drive toast                 5s     869ms    322ms    633ms
  secret heading                      10s    6263ms   8242ms   4650ms
  cross-context Name                   5s    3266ms   2081ms    554ms
  whole test                          60s     41.9s    43.5s    23.7s

Three of those are marginal and two are not.

The secret heading sits behind the drive creation above it, which is several
signed commits before the step mounts, and its worst sample was at 82% of its
budget. That is the assertion 4326 failed on.

The cross-context wait is the heaviest step in the test on what was its
shortest budget: a second browser context navigating to /app/edit and waiting
for the profile resource to arrive from the server, while the assertions either
side of it already carried 10s. It is what fails on a loaded box here, which is
a different line from the one CI failed on, so this test had two marginal
assertion budgets rather than one.

The per-test budget was a third, independent cause, the same shape as mt940:
42-44s of a 60s default with nothing wrong, so an assertion fix alone would
have left it losing on the test budget. `test.slow()` takes it to 180s.

The profile-name heading and the drive toast are left alone. Nothing behind
them is slow, and 86ms against 10s is not a budget worth touching.

The comments record the measured ranges so a future reader can tell a hang from
slowness without re-measuring.

Validated 3 of 3 under the same load at 41.3s, 39.0s and 23.9s. The three
remaining failures in that run are `tables:63`, which cannot pass in this
sandbox because it needs outbound HTTPS, and which fails identically with and
without this change.
`plugins.spec.ts:165` failed all three attempts on develop run 4326, reported
as the test timeout rather than as any assertion, which is the whole tell: it
carries two 45s waits on the suite's 60s default, so neither could ever fire.
The wall always reported first and always named itself instead of the step.

Every other test in this file carrying a 45s wait already raises its budget,
and the test immediately below this one says why in the author's own words:
"The wait below can take 45s of this; the suite's 60s default leaves nothing
for the rest of the test." This was the one that did not.

Timed step by step under four-worker load, three copies:

  step                       budget   run A    run B    run C
  setup through the alert         -    5.0s     4.2s     1.9s
  approve-enabled               45s   29.9s    33.4s     8.3s
  proxy-task visible       default     49ms     32ms      6ms
  sync-complete                 45s    4.3s    (wall)     1.0s
  whole test                    60s  (wall)   (wall)    34.0s

Run B settles it. It cleared `approve-enabled` at 33.4s, cleared the step
after, entered the sync with 33 seconds already spent and then stopped, killed
mid-step with that step's own budget untouched. Both failures are the wall and
nothing else.

So only the wall changes. The two 45s waits stay as they are: the worst
`approve-enabled` sample is 33.4s of its 45s, on a box harsher than the shard,
and at a 120s wall that assertion can fire for the first time in this test's
life. A future failure then names the step that was slow instead of reporting
the wall, which is the diagnostic that has been missing all along. Raising
them would trade it away for headroom the measurement does not ask for.

The comment records the table and points at run B, so nobody re-derives this.

Validated 3 of 3 under the same load at 1.2m, 1.1m and 32.3s. Two of the three
ran past the old 60s wall, which is the fix doing its job rather than a
coincidence. The three remaining failures in that run are `tables:63`, which
cannot pass in this sandbox because it needs outbound HTTPS.
`test.setTimeout` applies to the running test, not to the function it is
written in. So a bare call inside a helper overwrites whatever the caller
asked for, in either direction, with no error and nothing in the log to say it
happened.

`newPlugin` set 120000. `plugins.spec.ts`'s sidebar test declares 240_000
three lines before calling it, with a comment explaining why it needs the
room. That test has never once run on 240s. It ran on 120s and died at a wall
it had itself raised, reporting `Test timeout of 120000ms exceeded` on a test
whose second statement asks for double that.

`newApp` in `apps.spec.ts` is the same shape. It is harmless today only
because nothing in that file declares a budget, which stops being true the
first time someone adds one. Both are fixed here rather than one, since a
latent instance of a trap with no error message is worth as much attention as
a live one. These two are the only helpers in `browser/e2e` that call
`test.setTimeout` outside a test or hook.

Both now raise and never lower, and both leave `timeout === 0` alone, since
Playwright uses 0 for "no timeout" and a bare `Math.max` would quietly hand a
ceiling back to a test that had deliberately removed one. `test.info()` throws
outside a running test; every call site of both helpers is inside a test body,
none in a hook.

Also in this commit, two budgets measured under four-worker load.

`plugins.spec.ts:31` failed all three attempts on run 4326, reported as the
60s test timeout and naming the `Last synced` wait. That name is an artefact:
the wall prints whichever assertion was in flight, and a test's longest
ceiling is the likeliest to be holding it. Timed, three copies:

  step                            budget   run A    run B    run C
  integrations link through connect    -    5.7s     5.9s     4.9s
  complete install, open folder        -    4.5s     5.1s     5.6s
  `Last synced`                      60s    8.2s     7.1s     7.2s
  open the Pets table            default    0.9s     0.6s     0.5s
  rows and datatypes             default    2.5s     1.7s     0.5s
  ------------------------------------- sum 21.9s   20.5s    18.8s
  whole test                         60s   43.6s    38.6s    36.6s

`Last synced` never passes 8.2s, and 18 to 22 seconds of each run go on
`beforeEach` before the first step above begins. The test is marginal as a
whole, at 73% of its wall on the worst sample, so the wall lands wherever it
lands. 120s for the test, and `Last synced` comes DOWN to 30s: a ceiling equal
to the wall can never fire, so it could only ever be reported as a casualty.
At 30s it can fail on its own terms and name itself.

The second Code-tab click in the sidebar test is the one that failed on run
4330, all three attempts, on `use.actionTimeout`'s 10s. It is the first
interaction after a full navigation, so the editor remounts and renders its
tab list before the click can land. Measured at 1.5s, 3.9s and 5.4s across
three copies of one run, rising with the store rather than varying randomly:
already 54% of the ceiling with the trend still going up. It gets 30s. The
click before it, which follows an in-page edit rather than a navigation,
measured 106ms, 103ms and 128ms and is left alone.

Validated 9 of 9 under a four-worker mix: the Pets test at 41.2s, 37.0s and
33.1s, the sidebar test at 2.3m, 2.0m and 1.9m, and the Notion proxy test,
which shares the same file, at 1.1m, 51.9s and 43.2s. The sidebar copy that
ran 2.0m is the sharpest evidence for the helper fix: that is 120 seconds, the
exact wall it used to be given.

The three remaining failures in that run are `tables:63`, which cannot pass in
this sandbox because it needs outbound HTTPS.

One caveat on the Pets validation. That test skips without
ATOMIC_MOCK_INTEGRATION_PROXY, and even with it the app's proxy default is
baked in at build time as VITE_INTEGRATION_PROXY_URL, which CI's e2e build
sets and a local build does not, so the integration card is never listed. The
runs above pinned `integration-proxy-url` in localStorage the way
`google-calendar-import.spec.ts` and the Notion test already do. That pin is
not in this commit and touches no budget, but it is a difference between what
ran and what ships.
`apps:93` and `apps:182` both flaked inside `createFromCatalog` on develop run
4334, on its 45s `not.toHaveURL` wait. The call log is 90 identical polls over
the full 45 seconds, the URL never once changing from
`/app/new?parentSubject=...`, and that is all the run has to say about it.

That log cannot distinguish the two things it could mean. `openCreation`
(NewRoute.tsx:205) navigates only after the template has finished building, and
its catch calls `store.notifyError` and navigates nowhere. So a creation that
threw at second two and a creation still working at second forty-four leave the
page on exactly the same URL, and this wait reports them with the same 90 polls
and the same message. One of those is a budget that is too small. The other is
a bug, and no amount of extra budget will find it.

`errorHandler` (data-browser/src/handlers/errorHandler.ts) calls `console.error`
before it raises the toast, and window's unhandled-rejection hook reaches it
too, so the page's own console is the one place that separates them. This
collects it for the length of the step and prints it only when the wait fails,
then rethrows the original error untouched so Playwright's call log, which is
the useful half, is still there.

No budget moves. The wait is still 45s, and whether 45s is right is now a
question that a future failure will answer by itself instead of leaving the
next reader where this one started.

Measured while validating, four workers, `catalog` to leaving `/app/new`:

  title      n    min      med      max     worst as % of 45s
  App       30   13.8s    16.6s    29.7s          66%
  Plugin     2    9.7s     9.9s     9.9s          22%
  Website    2    4.6s     4.8s     4.8s          11%

So the 45s is really an App budget, and App is the one that flaked. 66% of a
ceiling under load is marginal by the standard the rest of this suite now uses,
but it is not yet a reason to raise anything: both CI flakes are equally
consistent with a creation that failed, and this commit is what will tell us.

Both branches of the new message were proven rather than assumed, by forcing
the wait to 1ms: with a `console.error` injected into the page it prints "the
page reported: ...", and without one it prints "the page reported no error, so
the creation had not finished within the budget". Pass path unchanged, 20
passed and 2 skipped across apps, website, website-publishing and
integration-visibility at four workers with two copies each, covering all three
titles this helper is called with.
* Close mobile AI chat when opening resource links

* Refresh AI credits and move balance into AI Chat options
* Make the Clippy pre-commit hook incremental

The staged-snapshot hook rebuilt the entire workspace on every commit, and
worse, ran the full JS build first: the snapshot has no `dist` and no
`assets_tmp`, so server/build.rs ran pnpm install, vite and wasm-pack plus
the wasm32-wasip2 plugin runtime — none of which Clippy needs. Skip both
the way CI's rustChecksContainer does, with the same assets_tmp stub.

Cargo fingerprints path packages by their path and detects staleness by
mtime, so a fresh mkdtemp snapshot per commit could never reuse anything.
The snapshot now lives at a fixed target/pre-commit/snapshot and is synced
incrementally: the hook records the `git write-tree` OID it last checked
out and only re-checks-out / deletes the paths `git diff-tree` reports
against the current index. Partial staging works as before.

Warm runs go from a full workspace build to ~6-10s for a one-crate edit
and ~2s when nothing changed.

Also fixes a pre-existing clippy::unnecessary_to_owned in lib's website
tests, which the -D warnings hook blocked on.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* Key the pre-commit snapshot per checkout and lock it

Worktrees commonly share one CARGO_TARGET_DIR, so a single
target/pre-commit/snapshot would be raced by two of them committing at
once. Put each checkout's snapshot under a hash of its root path.

Git does not hold index.lock while pre-commit runs, so two commits in the
same checkout can also overlap; Cargo's target-dir lock covers the build
but not the snapshot sync. A pid lock file makes the hook wait for the
other run, and a lock left by a dead process is reclaimed.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* pre-commit: give the snapshot its own empty .git so ignore-aware tools stop there (#1607)

The persistent snapshot this PR introduces lives under target/, which the
repo's own .gitignore excludes. With no .git of its own, oxlint's file
walker searches upward for a repository boundary, finds the real repo's
.git, and applies its /target ignore rule to the whole snapshot -- every
file under it reads as gitignored, so oxlint reports "No files found to
lint" for every package, even ones the commit never touched.

Verified with git check-ignore (matches .gitignore:1:/target) and by
adding this same empty .git marker by hand: lint immediately finds and
checks all files again (lib: 212 files, data-browser: 1225 files, etc.),
same as before this PR moved the snapshot inside target/.


Claude-Session: https://claude.ai/code/session_01AHZRWHyQNxcw5fbTUSm3Hm

Co-authored-by: Claude <noreply@anthropic.com>

---------

Co-authored-by: Michiel de Jong <michielbdejong@ontola.io>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
* Consolidate AI settings and add push-to-talk voice conversations

* Type the managed voice test environment

* Update E2E navigation for reorganized settings

* Make AI and plugin E2E fixtures deterministic

* Wait for drive genesis acknowledgement before live sync

* Use outbox acknowledgement to gate new-drive subscriptions
…ies (#1626)

* Keep compact navbar presence visible and back off failed retries

* Apply recovery retry lint spacing

* Avoid inferring remote data from an unreadable workspace
@joepio
joepio merged commit 756741d into develop Sep 22, 2026
2 of 3 checks passed
@joepio
joepio deleted the claude/atomic-server-docs-refresh-jv8w40 branch September 22, 2026 17:58
@gitguardian

gitguardian Bot commented Sep 22, 2026

Copy link
Copy Markdown

⚠️ GitGuardian has uncovered 1 secret following the scan of your pull request.

Please consider investigating the findings and remediating the incidents. Failure to do so may lead to compromising the associated services or software components.

🔎 Detected hardcoded secret in your pull request
GitGuardian id GitGuardian status Secret Commit Filename
26549932 Triggered Generic High Entropy Secret ae276d3 browser/data-browser/src/helpers/standardLocations.test.ts View secret
🛠 Guidelines to remediate hardcoded secrets
  1. Understand the implications of revoking this secret by investigating where it is used in your code.
  2. Replace and store your secret safely. Learn here the best practices.
  3. Revoke and rotate this secret.
  4. If possible, rewrite git history. Rewriting git history is not a trivial act. You might completely break other contributing developers' workflow and you risk accidentally deleting legitimate data.

To avoid such incidents in the future consider


🦉 GitGuardian detects secrets in your source code to help developers and security teams secure the modern development process. You are seeing this because you or someone else with access to this repository has authorized GitGuardian to scan your pull request.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants