Skip to content

build(deps): bump @earendil-works/chord from 1.5.0 to 1.5.2 in /agents/pi - #74

Open
dependabot[bot] wants to merge 1 commit into
masterfrom
dependabot/npm_and_yarn/agents/pi/earendil-works/chord-1.5.2
Open

dependabot[bot] wants to merge 1 commit into
masterfrom
dependabot/npm_and_yarn/agents/pi/earendil-works/chord-1.5.2

Conversation

@dependabot

@dependabot dependabot Bot commented on behalf of github Nov 16, 2026

Copy link
Copy Markdown
Contributor

Bumps @earendil-works/chord from 1.5.0 to 1.5.2.

Release notes

Sourced from @​earendil-works/chord's releases.

v1.5.2

New Features

  • Fork sessions whose folder is gone: when a session's original folder was moved or deleted, you can now fork it into the current folder instead of only continuing, so later resumes no longer ask. See Continue or switch sessions.

Changed

  • When a session's working directory no longer exists, for example after the project folder was renamed, interactive mode now offers Continue, Fork, or Cancel instead of only continuing. Continue runs the session in the current directory without storing the choice, as before; Fork copies it into the current directory as a new session with a new ID, like --fork, so the next resume no longer asks. This applies at startup (--session, --resume), to /resume, to /import, and to ctx.switchSession() from extensions (#11975 by @​petrroll, fixes #11060)

Fixed

  • Fixed /import of a session whose working directory no longer exists leaving a copy in the session directory, and continuing it leaving a second copy with the same ID (s.jsonl and s-1.jsonl); the failed copy is now removed (#11975 by @​petrroll, fixes #11060)
  • Fixed Anthropic OAuth requests reporting an outdated Claude Code version

v1.5.1

New Features

  • Shell login and logout: use pi auth login <provider> and pi auth logout <provider> without starting a session, with API-key and no-browser sign-in options. See Credential commands.
  • Idle prompt cache warming: eligible caches now stay warm for up to 30 minutes between runs when a refresh is expected to pay for itself. See cacheWarming.
  • Anthropic message threads: requests send only new messages while the server continues the conversation, with full-request fallback when earlier context changes. See Anthropic compatibility.
  • Richer Mermaid diagrams: pie charts, author-defined styles, clickable labels on supported terminals, and diagrams in expanded branch and compaction summaries. See Display settings and Markdown transformers.
  • GitHub Copilot classifiers: call Microsoft-Decision-1 through codemode models.classify() for typed decisions and probabilities. See Use classifier models.
  • Package update summaries: pi update --extensions reports each package's npm version or git commit change and distinguishes unchanged, skipped, and warned updates. See Update Pi or packages.

Breaking Changes

  • Custom GrepOperations.readFile callbacks are no longer called for context lines. The field remains accepted as optional and deprecated so existing integrations still compile. The grep tool now takes context lines from ripgrep and no longer reads matched files itself. To search a remote system, override grep's execute(); see Remote Execution (#9276)
  • OpenAI-compatible models no longer send "tools": [] when all tools are disabled in a session that has used tools; the field is omitted. This fixes 400 errors (tools must not be an empty array) from vLLM 0.20+, also behind LiteLLM. If your proxy requires tools once the history has tool calls, such as older LiteLLM versions in front of Anthropic, set compat.requiresToolsWithToolHistory: true for that model in models.json (#11843)

Added

  • pi update now lists each updated package with its npm version or git commit change, for example npm:foo 1.2.0 -> 1.3.0, and prints Packages are already up to date when nothing changed. When nothing changed but an update printed a warning, for example because npm left the old version installed after resolving stale registry metadata, it prints No packages were updated, see the warnings above instead; in offline mode it prints Skipped package updates (offline mode). PackageManager.update() reports each changed package as a new result progress event whose message holds that line (#11707, #11711)
  • Anthropic sessions now use message threads: each request sends only the new messages and the server continues from the previous reply, falling back to the full request when the conversation changed (for example after compaction or a tool list change). On by default for the anthropic provider on api.anthropic.com; set compat.supportsMessageThreads in models.json to enable it for gateways that forward the thread field, or to turn it off. Cache warming does not touch the session's thread (#11545)
  • pi.registerMarkdownTransformer() takes an optional { messageTypes } that selects the Markdown surfaces a transformer runs on. Besides user, assistant, and thinking Markdown, transformers can now opt into custom (custom messages and skill blocks), summary (branch and compaction summaries), and changelog (What's New, /changelog, the Extension Updates notice, and the Update Available note). Without options a transformer runs on user, assistant, and thinking Markdown as before. The built-in Mermaid renderer now also draws diagrams in expanded branch and compaction summaries
  • pi auth login <provider> logs in to a provider from the shell without starting a session, for example pi auth login radius. It signs in with an account in the browser and exits; --api-key saves an API key instead, and --no-browser uses device code or copy-code sign-in instead. Logging in to Radius also configures the Radius MCP server. pi auth logout <provider> removes the stored credentials, like /logout
  • ctx.ui.custom() overlays now honor the blocked option: pi reports blocked program status (OSC 7501) from when the overlay is shown until it calls done(), also while it is hidden with setHidden(). Closing one overlay keeps other open questions blocked (#11816)
  • Added the qwen-token-plan-individual-cn provider for Qwen Token Plan Individual on the China endpoint, using QWEN_TOKEN_PLAN_CN_API_KEY (#7989 by @​bigoldcat123)
  • Added Microsoft-Decision-1 classifier support through GitHub Copilot, including codemode models.classify() (#11679 by @​Marvae)
  • Added compat.promptCacheKeyMode ("auto", "enabled", or "disabled") to enable prompt cache keys for compatible proxies or omit them for endpoints that reject them. Set it in models.json when using pi (#9442 by @​dannote)
  • Added compat.requiresNonNullAssistantContent for OpenAI-compatible endpoints that require an empty string instead of null in assistant messages containing only tool calls. Set it in models.json when using pi (#8118 by @​gaoyk19)
  • Added syntax highlighting for Dart, Nix, Groovy, and Gradle files in read and write views (#11643)
  • Added GLM 5.3 to the Qwen Token Plan Individual model allowlist (#11658)
  • Added Claude Fable 5.2 (claude-fable-5-2) to the anthropic provider ($8/$40 per million input/output tokens, 1M context, 128K output). Like Fable 5.1 it uses per-message effort and mid-conversation system messages; requests its safety classifiers refuse before any output are answered by Claude Opus 5 through server-side fallback and billed at Opus 5's price. Claude Fable 5.2 and Mythos 5.2 on other providers, such as OpenRouter's anthropic/claude-fable-5.2, get the same per-message effort support

Changed

  • The default model for the anthropic provider is now Claude Opus 5.5 (claude-opus-5-5) instead of Claude Opus 4.8
  • Default models moved to newer models at the same or a lower price: amazon-bedrock Claude Opus 5.5, azure GPT-6.1 Sol, google and google-vertex Gemini 4 Argon, vercel-ai-gateway GLM 5.3, baseten GLM 5.3, minimax and minimax-cn MiniMax-M3, qwen-token-plan and qwen-token-plan-cn Qwen3.8 Max, opencode-go Kimi K3.1 Pro, and Kimi K2.7 Code instead of Kimi K2.6 for moonshotai, moonshotai-cn, huggingface, opencode, openrouter, cloudflare-workers-ai and cloudflare-ai-gateway
  • cacheWarming now defaults to "idle" instead of "streaming": pi also keeps eligible prompt caches warm for up to 30 minutes between agent runs, but only when a refresh is expected to pay for itself. Set "cacheWarming": "streaming" in global settings for the previous behavior
  • Consecutive cache warms now show as one Cache warmed: $<total> line with the cumulative cost instead of one line per warm

... (truncated)

Changelog

Sourced from @​earendil-works/chord's changelog.

[1.5.2] - 2026-11-10

[1.5.1] - 2026-11-09

Breaking Changes

  • Chord v2 is the package's root: @earendil-works/chord exports v2 (was @earendil-works/chord/next). Chord v1 moved unchanged to @earendil-works/chord/old (was the root) and @earendil-works/chord/old/node (was /node); it stays until p2 runs on v2. The foundations v1's root re-exported have their own subpaths: @earendil-works/chord/json (JsonValue, JsonRepresentation, copyJson, isJsonValue) and @earendil-works/chord/watch (Watch, NativeWatch and the watch types), beside /context and /delta. Migration: imports of @earendil-works/chord/next drop /next; v1's imports of @earendil-works/chord become @earendil-works/chord/old, and /node becomes /old/node; imports of Context, Draft, JsonValue, copyJson or the watch types from the root move to /context, /delta, /json and /watch. In the repository, v2's src/next is now src, src/next-node is src/node, src/next-web, src/next-react and src/next-tui are src/web, src/react and src/tui, v1 is in src/old, and tests and docs moved likewise (test/next to test, docs/next to docs, v1's to test/old and docs/old).
  • Chord v1 (@earendil-works/chord/old, @earendil-works/chord/old/node) removed, with its tests and docs (src/old, test/old, docs/old). Apps still on v1 pin @earendil-works/[email protected].
  • Chord v2's startWorker no longer takes telemetry (it was added unreleased in slice 9): with a telemetry store on the server, the kit's workers send their spans and metrics to it, and no worker opens the store's file. startServer's telemetry is a store with ingest (createSqliteTelemetry's). Migration: drop telemetry from startWorker and the store's path from the worker's environment.
  • Chord v2's createWorkers returns a promise and rejects when the worker base does not build (decision "Workers start from the base code the server booted with"): it bundles the worker kind's entry and the base code it imports once with esbuild (--conditions from execArgv; Node builtins and packages resolved under node_modules external, by their files; workspace packages linked into node_modules inlined; import.meta.url and __dirname naming each source file; split at each dynamic import() esbuild can follow, so a lazily imported module and the packages it imports load only when the worker imports it; inline source maps, forked with --enable-source-maps) into a private temporary directory removed at close, and forks every worker from that snapshot: an edit of the app's source while the server runs (an agent half way through a change) no longer reaches workers forked later, which kept failing to start until the edit was fixed; a server restart applies it. workers.inputs lists the files the base was built from; the app kit's startServer builds each worker kind's base before loading (a broken one rejects the start, everything closed) and marks base when one of those files changes (it marked only the entry).
  • Chord v2's host.reload restarts every live object of a changed plugin; the pure swap in place is removed (decision "Reload restarts every affected object; old work finishes on old code"). ReloadReport.objects no longer has the kind swapped: a live object is restarted, or parked { cause } when its successor's recorded requests find a failure. Old work (the calls running at the commit and every call they cause through their ctx, and calls marked old over a trusted link) runs on the object's open old attempt; new calls wait at the gate for the new code. The old attempt is sealed once that work drained and its successor's requests are ready, bounded by the new host option reloadDrainTimeout (default 5 s, at most closeTimeout; the app kit's timeouts.reloadDrainTimeout reaches the server and every worker): a method still running then is cut released and reported drain_timeout. A wait of old work that its own old attempt blocks fails at once with unavailable/reload_cycle; a getter of old work for a version the new code dropped binds the open old attempt or fails at once. call gains old (binary flag 0x20, the text codec's seventh element; a relay drops it from untrusted links; PROTOCOL_VERSION stays 1); waiting causes keep the reason unavailable/version. Consequences: a reference shows loading briefly after every reload of its object (it stayed bound across a swap); a value read right after host.reload resolves may still be the old code's; an in-memory job run ends aborted { reload } at every reload of its object (it finished on its old code across a swap); routines restart when the successor goes live. Migration: drop swapped from code reading the report; open a root inside a method with withoutAbortSignal(ctx), not a fresh context, so its calls are old work; move work longer than reloadDrainTimeout into jobs.

Added

  • The sync layer (experimental): @earendil-works/chord/sync moves a store between devices through a remote, from the store's outbox (openStore(backend, ctx, { outbox: true })). Every device continues a store as its own: uploadSession() uploads the outbox commits after the last sequence the copy shares with the remote as one gzip batch into a slot the remote creates once per start sequence, trims the outbox through what the remote acknowledged, and reports a copy as diverged when another device's upload created that slot first, or behind when its head fell below what it had uploaded. A store whose outbox does not reach back to its first commit starts with an archive slot (store.export()). pullSession() catches a copy up through applyBatch(), resumes an interrupted pull, or restores into an empty backend (importStore() for an archive); foldSession() folds the history into a snapshot archive, keeping folded slots taken. FlushScheduler decides when to upload. FileSystemSyncRemote, a remote in a directory, and FileSyncStateStore, sync state in a directory, are for development and tests; they take their file operations as a SyncFileSystem (Pi Durable's environments fit it as they are).

  • Chord v2's Node components and client surfaces are exported: @earendil-works/chord/http, /workers, /workers/child (the worker's side, workerMain and processLock, without esbuild), /plugins, /plugins/runtime and /app; /surfaces (the web and terminal surfaces' server side), /web, /react, /tui and /tui/launcher.

  • Chord v2's plugins component gains the plugin model (slice 12): createPlugins({ api: { name, versions } }) checks every import of the app's versioned API (@acme/app/v3, per-kind modules such as @acme/app/v3/web): an unlisted version, another kind's module, two versions in one facet and a direct import of Chord are build errors naming the file and line. Roots may be { path, required }: a required root's plugin failing at load rejects it with a PluginError after the load settled. Files named <name>.<kind>.<ext> (contract.web.tsx) are of that kind, refused in facets of another kind with the chain of imports named. Single-file plugins (hello.server.ts at a root's top, grouped by name, host packages only). installPlugin({ git, ref } | { npm, version }, root, ctx) installs plugins from git (a shallow clone of a branch, tag or commit; a repository of several plugins too) or npm; a package lists the plugin folders it provides in its package.json ("chord": { "plugins": ["./notes", "plugins/*", "!plugins/draft"] }), used by discovery and installPlugin (without it: one plugin when the package's top has facet files, else its subfolders with a package.json). testPlugin(dir, { kind, modules, stubs, principal }, ctx) builds a plugin as production does and loads it on an in-memory host beside stub facets, collecting its contributions to registries nobody serves and listing the contracts it waits for. Agents' guide: docs/plugin-authoring.md.

  • Chord v2 gains the app kit (slice 13, @earendil-works/chord/app): startServer<P>({ name, dataDir?, root?, listen?, api, kinds, principal: { server, worker?, owner }, workers?, files?, install?, onError }, ctx) lays out the data directory (server/store.sqlite, workers/<kind>/<address>/, plugins/, logs/, owner-token; one server per data directory), creates the server's store and host, HTTP, one workers component per worker kind and the plugins component over the app's required root and the user's root, and loads the server's plugins with the kit's objects; startWorker({ api, kinds, busy?, onError }) is a worker's entry (its directory and store, the link to the server first, its plugins). The start-data objects AppInfo (with the owner) and WorkerInfo serve process values to plugins. Sessions (Sessions: issue, verify, revoke, list; tokens kept as SHA-256 hashes, compared in constant time; persisted ones end after 400 days unused and their browser cookie is renewed daily while used, ephemeral ones live in memory, at most limits.ephemeralSessions) authenticate a signed HttpOnly, SameSite=Strict cookie or Authorization: Bearer; a one-time owner link per start (app.ownerLink(), the token in the URL's fragment, single use, 10 minutes), an owner token file (mode 0600, written atomically) and device pairing (POST /_chord/pair, owner approval, a poll returning the token once; bounded in all and per client address) sign the owner in: principal.owner, any principal of the app (strict JSON, not the server's), recognized by canonical JSON. The data directory, its stores and secret files are made private (0700, 0600) at every start; the home directory, a file system's root and another user's directory are refused. Files per host: small and chunked writes at a stored offset, ranged reads, a watchable index, caps, at most limits.uploads uploads under way. app.exportData(address, path, ctx) and app.importData(archive, address, ctx) move the data a worker created (its store and files) as a tar without stopping anything: a running worker writes its own store at one consistent point, else the server reads it under the worker's process lock (import refusing an existing address, another app's archive, every path leaving the target, and archives past limits.importBytes or limits.importEntries). app.applyChanges(ctx) and app.plugins.install(source, ctx). Optional plugins as exported facets: defineUsers(profile), inviteFacet(), ephemeralLoginFacet().

  • Chord v2 gains web and terminal surfaces (slice 11): webSurface and tuiSurface (@earendil-works/chord/surfaces) build a client kind's base bundle from the app's entry at start (content-hashed, served forever) and publish its plugins' facets as scripts that register themselves (chordFacet("<plugin>", "<digest>", function (require, module, exports) {…})) and one combined file, with WebScripts and TuiScripts showing the current set (a rollout step publishes without waiting for clients) and the page served through the app's own template (PageAssets, pageScripts). startPage (@earendil-works/chord/web) runs a page's client host: the connection loop (keepConnected: 250 ms doubling to 5 s, wakes, silent sockets, canRetry), plugins applied in place on a new set (a failed one keeps its old facet), a reload when the server's base bundle changed, and the active theme as CSS variables. React bindings (@earendil-works/chord/react): HostProvider, useHold, useWatch, useRegistry, useRefState (React is an optional peer dependency). The terminal: startTerminal (@earendil-works/chord/tui/launcher) signs in with a token, a token file or device pairing and runs the app's terminal code always in a sandbox (a child process on pipes with Node's permission model: no file system, terminal, processes, workers, network or SQLite; Node 26.5.1 or later), filtering its output, relaying its link and confirming its actions (copy, open a URL, attach a file the user names); startTerminalRuntime and TuiScope (@earendil-works/chord/tui) inside it. Themes: the Themes registry, ThemeChoice (one dark and one light pick per principal), followActiveTheme, themeVariables, terminalColor. startServer gains web and tui. Plugin builds scope *.module.css files per plugin and file. Ephemeral sessions end with their client's last link (after a minute). The HTTP component's links endpoint gains an opened hook.

  • Chord v2's HttpRequest gains remoteAddress, the peer's address as the listener knows it (for limits per client).

  • Chord v2's HTTP component gains readSignedCookie(request, name, secret): readCookie's value with its signed expiry, for renewing a cookie before it expires.

  • Chord v2's root exports invalid(reason, message, details?) and the new forbidden(message, details?), the ChordErrors a plugin throws for arguments or params it refuses (invalid/args, invalid/params) and for a principal it refuses (forbidden); an app's API re-exports them, and the caller gets the same { code, reason } as from Chord's own checks.

  • Chord v2's React bindings gain usePageState(key, initial), useState's pair with the value kept by the page's host under key instead of the component: a component of a reloaded web plugin is a new function and remounts (its useState starts over), and page state is what survives (a half-typed message, a scroll position); any value, never on the wire, gone with the page. TuiScope gains pageState(key, initial) on the same per-host store, its changes calling the scope's changed.

  • Chord v2 reports mistakes that waited silently through onError (decision "Mistakes that wait are reported at once"): unbound_long { waitingFor, error, since }, a request waiting unbound (a type or registry not served here, not at its version, a registry whose first compose threw) once after 5 s, on one timer per host (it keeps waiting until its readyTimeout); registry_undeclared { registry, plugins }, a registry with contributions and no provider at a publication (load, a reload's commit) or when a host-lifetime object's contributions enter, naming the contributing plugins, again only once they change; transaction_cancelled { object, error }, a document change or transaction that did not commit because the context it was started with ended first (a root whose fn returned, a caller that cancelled, its object's end), besides rejecting.

  • Chord v2 gains live queries: self.query(table, q, limit) in the factory of a table's owner is a watchable of the query's rows (at most limit, in its order), usable as a state member and a derive source. Chord runs it before the object goes live and again inside the commit step of every commit of the object that writes the table, publishing only the diff in that commit's batch; a commit writing no table with a live query runs nothing (chord.query.runs counts the runs). Only the object's own tables; the limit is required (invalid/args at declaration). A run that fails (a row the code cannot read) is a failed member, reported once as the new HostError query_failed { object, table, error }, and heals at the next good run. Each touching commit runs the query once (100 rows: about 60 µs, 80 µs watched): not for tables written hundreds of times a second.

  • Chord v2 gains messages and languages in the app kit (design §23): defineMessages(namespace, { en: {...}, de: {...} }) returns a typed t(key, ...args) (the first catalog types the others: a missing key, an unknown one or a wrong argument is a type error; values are strings or functions), t.message(key, ...args) builds a message as data (MessageData, { namespace, key, params }, for state members typed with MessageSchema), t.render(message) renders one (a foreign namespace or an unknown key from a link shows the key), t.translations lists its catalogs, and MessagesOf<typeof t> types a translation. The Translations registry takes a list of { namespace, locale, messages, override? } per contributor (one catalog per namespace and locale: the first by plugin name wins, reported; override: true wins); a missing key falls back down the locale's chain (pt-BR, pt) to the first catalog, reported once. LocaleChoice keeps one locale per principal on the server (the theme choice's store, now shared as one preference); a client follows it with followActiveLanguage, defaulting to navigator.languages on a page and the system locale in the terminal (startTerminal's locales), matched against the catalogs, switched live. useMessages(t) (/react) and TuiScope.messages(t) (/tui) render in the host's language and re-render or redraw on a change; startPage sets lang and dir on the page (followLanguage, /web); formatTime and formatNumber use Intl in the language being rendered. The kit serves Translations on the server, workers, pages and terminals and LocaleChoice on the server; client errors gain { kind: "messages", report }.

  • Chord v2 gains telemetry across hosts (slice 9): CHORD_TELEMETRY_SCHEMA (root export) types every span, event and metric Chord records. With a host adapter (createHost({ telemetry })), calls (chord.call), methods (chord.method, local and remote), relays (chord.relay), holds (chord.hold), activations (chord.activate, ending live, failed, parked or ended, with chord.retry and chord.park events), natives' opens and closes, load, reload (a chord.reload.fate event per object), resolves (a worker start included), revocations, routine calls, job phases (intent, run, finish: a persisted run resumed in a new attempt or process stays under its stored carrier) and HTTP requests (chord.http: method, route pattern, status, never the path) are spans; failures carry a fixed category and the message cut at 500 characters, a cancel is no error; commits are chord.commit { documents, ops, rows, duration } events of the span they ran under. hold and call carry the caller's trace carrier (trace, at most 8 keys, keys and values of at most 256 characters of printable ASCII, else the message fails the message schema and the link closes; the binary codec's kind byte flag 0x40), relays forward their own span's, and the provider runs the method under it (an absent or unknown carrier: the adapter's root); a reference's carrier rides on its first hold only, a re-hold after a reconnect being a fresh root linked to it. A hold's type and its address's kind are bounded at 256 characters by the message schema, and span attributes a peer chose at 256 characters. ctx.trace(name, attributes, fn) runs fn in a child span with a child ctx. Host-wide metrics: chord.link.bytes, chord.link.state_messages, chord.commit.duration, chord.calls.in_flight, chord.holds.active, chord.links.open, chord.park.duration, chord.backpressure.wait. Without an adapter nothing is started, built or sent: a call over a link costs what it did before. createHttp, startServer and startWorker take a telemetry adapter (createHttp continues a W3C traceparent only from a request a contributed relay verified: an app's proxy must strip it from browsers). A host with an adapter counts the cost counters of its links' and root scopes' work on it also when the app passed a context without a span. The SQLite telemetry store keeps spans of one microsecond in the order they started.

  • Chord v2's telemetry closes four gaps found writing the tutorial: chord.commit counts the table rows a commit's writes changed (rows; a commit writing only rows no longer reads documents=0 ops=0); every span Chord starts, ctx.trace's too, carries chord.host, the host's address key or client without an address (Host gains address); the SQLite telemetry store keeps span times in whole microseconds from pi-telemetry's telemetryNow (store version 2: a recorder migrates a version 1 file in place, its rows kept); and openTelemetryStore(path) (new subpath @earendil-works/chord/telemetry-sqlite/node) reads a store file read-only, implementing TelemetryStore only, refusing a file without a store or with one of another version. openNodeSqliteDatabase takes mode: "read-only".

  • Chord v2's telemetry is stored in one place, the server (decisions "Telemetry from browser pages", "The server is the one place telemetry is stored", "Who a span was for"). Pages and workers record in memory with Chord's TelemetryRecorder (the SQLite store's own recorder too) and send finished spans in batches over their link to the server's PageTelemetry and WorkerTelemetry (ingest(batch)), which the app kit serves when startServer has a telemetry store; the store gains ingest (never replacing a stored span). startPage({ telemetry: true }) records the page and sends its spans every 3 s and when hidden; the server checks a page's batch strictly (at most 100 spans, every field bounded, ids printable ASCII, no control characters), keeps only spans under the page's own ids (browser:<its incarnation>:<n>), caps them at 1,200 per page and minute, marks them chord.host: browser and stamps them with the principal of their link (a page's own chord.* attributes are dropped). A worker sends its spans and metrics every second, stamped with its host. host.root(fn, ctx, { trace: { name, attributes } }) runs fn in a new root span (a click). Method and call spans record whom they were for: chord.principal (the principal key) by default, or what the host's new principalAttributes hook returns (createHost, startServer, startWorker). ServeOptions.untraced serves a type whose calls start no method span. Host gains incarnation and principalAttributes.

  • Chord v2's TuiScope gains optimistic(read): the reader and show(value, call), which shows value in place of the reader's until every call shown settled (React's useOptimistic for terminal UIs). The guide's "Optimistic UI" shows React's useOptimistic and startTransition over a Chord call, what it relies on and what it does not cover; example 63-optimistic-answers.ts.

Changed

  • Chord v2's HTTP component denies by default (slice 13): a request or plugin socket without a principal gets 401 before plugin code runs unless its route or socket is marked public: true ({ handler, public: true }; a crossSite route is public), and the /chord links endpoint refuses requests without a principal.
  • Chord v2's host.get, host.hold, host.registry and a root's ctx.get on a host whose load was not called throw not_ready at once ("call host.load first") instead of waiting for a publication; a client with nothing to load calls load([]). Holds arriving on the host's links before load still wait for its publication. The HTTP component answers a request before load 503 at once.
  • Chord v2's host.load and host.reload throw for a plugin name that is no npm package name, before they change anything (it was listed in the report's failed).
  • Chord v2 plugins import each other by relative path within a root (copied into the importer's script) and across repositories by package name through the package's exports, pinned in dependencies; slice 10's imports by plugin name (@app/notes/contract) are removed, and a relative path leaving the root is a build error.
  • Chord v2's host.reload starts the objects' fates dependents first: removals, then the other fates in the reverse of the order the objects went live (the report keeps its order). A pure dependent reloaded with its provider (a view over a store in one plugin) binds the provider while it is still live and swaps instead of parking until the provider's new instance is live: its contributions are replaced in one batch and its holds over links never show loading. A dependent still parks when its new code needs the provider's new version, when its provider went live after it, or when it needs something not live.
  • Chord v2 keeps calls over a link across a loading unbind (decision "Calls in flight survive a loading unbind"): a hold whose object restarts, whose swap parks or whose live failure retries no longer answers its calls in flight unavailable; each is answered by the instance it already runs on or by the new instance once it is live (or by its failure, readyTimeout, its end), and calls a consumer sent by the old names before it saw the loading wait the same way instead of not_ready. A failed unbind (a removed type, a dropped version, a swap parked on a failed dependency) still rejects them.
  • Chord v2's store writes the commits queued behind a running commit step in one backend transaction (group commit, decision S18): each keeps its own seq, outbox commit and adoption in queue order, the metadata is written once; a refusal in a group rolls it back and runs its commits one by one, so only the refusing commit is refused.
  • Chord v2 sends a call's answer after its state (decision "A call's answer follows its state"): before a host sends a result or error, its own or one it forwards as a relay, it sends the origin's state still waiting for a slot of the window (one state message, past the window if it is full; acknowledged like any other). A call settling in a page now finds every change its answering host, and a relaying host, committed before answering, so an optimistic value is replaced by the real one instead of flickering back to the old value. Nothing extra is sent when nothing waits.

Fixed

  • Chord v2's workers on macOS and the BSDs: a worker killed by a signal (the grace's or the start timer's SIGKILL) left its lock's socket file, and every later start of its address failed with ... is a stale lock file, retry too, until the file was removed by hand. The workers component now removes a lock socket file nobody accepts on before each start and after a child's exit by a signal.
  • Chord v2's processLock on macOS spun until its context ended when a regular file sat at the lock's path (ENOTSOCK); it now fails closed naming the file, as for a socket file nobody listens on.
  • Chord v2's heartbeat closed every link after the process had slept (a laptop's sleep) or blocked its event loop, before reading what the peer had sent meanwhile. Time the process did not run no longer counts as silence: after such a pause each open link pings at once and closes only if its peer stays silent for close - ping (15 s by default).
  • Chord v2's workers no longer leave an address failed when a running worker loses its link (the heartbeat, a protocol error, the worker closing its own link): the worker is stopped, worker_link_lost { address, error } is reported, and its holders get a new worker. A second lost link within a minute of the last recovery still fails the address (public error worker lost its link). Crashes, fatals and failed starts still stay failed until retry or a rollout.
  • Chord v2's objects no longer answer a call not_ready during a reload while the caller sees them live: a call over a link to an object whose swap had parked (its new code waiting for a dependency) or whose restart had drained, sent while its hold was still bound to the old instance, got not_ready: ... not live yet. Such a call now waits for the object's new attempt (live, failed or ended), bounded by readyTimeout (unavailable/park_timeout); a parked attempt showing failed { waiting } rejects it with that cause; it stays when the hold then leaves the old instance with loading.

... (truncated)

Commits
  • b4afddd Release v1.5.2
  • 602b8d1 fix(chord): workers without --enable-source-maps, linked base map, lazy facet...
  • 8f0d358 fix(p2): conversation switches no longer re-fetch page-wide objects; compress...
  • 8a5da3c feat(chord): documents and table rows can belong to a host
  • 1989532 Add [Unreleased] section for next cycle
  • dd30101 Release v1.5.1
  • 23303ae fix: settle app fixture watchers before making test edits
  • 3b921e3 fix: resolve terminal sandbox paths before granting file access
  • cd5e3d2 fix: capture Chord GC test objects before releasing readers
  • 7e713da fix: stabilize Chord tests and preserve WebSocket close codes
  • Additional commits viewable in compare view

Dependabot compatibility score

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


Dependabot commands and options

You can trigger Dependabot actions by commenting on this PR:

  • @dependabot rebase will rebase this PR
  • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
  • @dependabot show <dependency name> ignore conditions will show all of the ignore conditions of the specified dependency
  • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
  • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
  • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

Bumps [@earendil-works/chord](https://github.com/earendil-works/pi/tree/HEAD/packages/chord) from 1.5.0 to 1.5.2.
- [Release notes](https://github.com/earendil-works/pi/releases)
- [Changelog](https://github.com/earendil-works/pi/blob/main/packages/chord/CHANGELOG.md)
- [Commits](https://github.com/earendil-works/pi/commits/v1.5.2/packages/chord)

---
updated-dependencies:
- dependency-name: "@earendil-works/chord"
  dependency-version: 1.5.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <[email protected]>
@dependabot dependabot Bot added dependencies Pull requests that update a dependency file javascript Pull requests that update javascript code labels Nov 16, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

dependencies Pull requests that update a dependency file javascript Pull requests that update javascript code

Projects

None yet

Development

Successfully merging this pull request may close these issues.

0 participants