Repository navigation
docs: tell the local-first story (URLs, Atomic Sync, Flutter, end-to-end guide) - #1552
Merged
Merged
Conversation
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
joepio
commented
Sep 19, 2026
- 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.
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
|
| 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
- Understand the implications of revoking this secret by investigating where it is used in your code.
- Replace and store your secret safely. Learn here the best practices.
- Revoke and rotate this secret.
- 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
- following these best practices for managing and storing secrets including API keys and other credentials
- install secret detection on pre-commit to catch secret before it leaves your machine and ease remediation.
🦉 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.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Related Issues
None. Follows the refactor from HTTP origins to
did:adidentifiers 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.mdandbrowser-peer-sync.mdnow sit under it as the wire reference and the WebRTC path.flutter.mdunder Clients / SDKs: the Dart SDK onatomic_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/libor the Flutter SDK exposes today; the one step that still needs a checkout (the WASM build) says so.Edited pages
js.mdandjs-lib/store.md:serverUrlis optional,createDrivewithlocalOnly,promoteLocalDrive, sync status,did:ad:subjects ingetResource.did:ad:over HTTP,/commitscorrected to/commit.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
🤖 Generated with Claude Code
https://claude.ai/code/session_018ZmptEWmdz92GXTuP77vrb
Generated by Claude Code