The open runtime for apps on NEAR — composed from published config and loaded through a shared host, UI, and API runtime.
Runtime:
A published app configuration (bos.app.ts authored, resolved through extends) that the host loads as remotes.
Avoid: app (ambiguous between the runtime and a tenant), project
EntryResolver:
The host's entry-URL seam (entryUrls in everything-dev/ui/remote-entry) — one pure derivation from a stamped remote (RemoteEntry) to the URLs each surface loads: ui (browser entry — bustered fixed name in development, digest-derived hashed outside it), ssr (server container entry; undefined when the remote has no SSR coordinates), and browserManifest (the digest-derived hashed mf-manifest, structurally absent for local remotes — atomic-deploys 08). Surfaces resolve lazily and throw loudly outside development naming remote + surface; buster arithmetic (integrity for ui, ssrIntegrity→containerVersion for the server) lives inside the module, never at call sites.
Avoid: SlotResolver (retired), web surface (retired — the browser surface is ui), resolveEntryUrlForEnv (the deleted per-surface helper), remoteEntryUrlOf/ssrEntryUrlOf/getSsrEntryUrl (the deleted per-site wrappers), buster at the call site
Quiet build:
The prerequisite dist builder in everything-dev/build — one function (buildPackageQuietly) over the three framework packages (every-plugin, better-near-auth, everything-dev), each identified by its staleness-check dist entry. Skips when the dist is fresh, rebuilds captured-output-quietly, and fails loudly on nonzero exit; used by bos build's train and the bos dev boot build.
Avoid: buildEverythingDevQuietly/buildEveryPluginQuietly/buildBetterNearAuthQuietly (the deleted triplication), force-rebuild as the default path
Authored surface:
The ui files an app owns and edits freely — routes, lib, components, plus the scaffolded-once router.tsx (router policy) and app.ts (@/app public surface). The framework owns none of it after init.
Avoid: framework files (ambiguous — the generated stubs are framework-owned too), boilerplate
Framework-owned file:
A child-repo file in the src/services/scaffold/ownership.ts inventory (everything-dev package) — reconciled from the parent template by bos sync / bos upgrade with three-way hash comparison, template-wins-on-conflict, and backups under .bos/sync-backup/ (ADR 0032). Local edits are legitimate; a permanent change requires an upstream issue at the framework repo, which ships it in package versions.
Avoid: sync file (implementation detail), boilerplate (ambiguous), "don't touch" framing (the marker says edits are allowed)
Upstream-change protocol: The standard for changing framework behavior (ADR 0032): edit framework-owned files locally when needed, then file an issue at https://github.com/NEARBuilders/everything-dev/issues describing the change — the framework team implements it in the parent repo via PR + changeset and ships it in package versions, after which the child copy and the template converge. A local edit without an upstream issue is an undocumented fork claim. Avoid: "you can't change this" (wrong), silent forking (the issue is the contract)
Generated stub:
A .gen-suffixed, gitignored ui file the framework emits — web entry, hydrate wiring, SSR router module, compose expose, globals — regenerated by dev/build/typecheck from the installed package version, never edited or synced.
Avoid: sync file, template file (sync no longer carries ui source)
Deploy leg:
One of the post-publish stages of bos deploy — image (build/push or pin the runtime image), smoke (the boot gate), railway (the redeploy trigger). Each leg reports an outcome (ok / skipped / failed + reason) on the deploy result; a skipped leg never fails the deploy.
Avoid: stage (dev/build/upload/publish are train stages, not legs), step
Runtime tier:
Whether the deploy train owns its runtime image — root (a Dockerfile at the config root or BOS_IMAGE; the train can produce a digest and must pin Railway to it) or child (inherits the platform's universal image per ADR 0020/0021; its image ref derives from the platform release manifest — no image bytes to build, pin, or boot). One function resolves it; the image, smoke, and Railway gates all consume it.
Avoid: root vs consumer (the account naming, not the image-ownership question), tenant tier
Remote:
A named position in the composition — app.<key>, app.<key>.ui, plugins.<id>, plugins.<id>.ui — and (loosely) the workspace it loads bytes from. The walker in src/services/remotes.ts derives every dotted path; never fork the traversal.
Avoid: config slot (retired — the ticket-11 vocabulary; attachment slots in the descriptor domain and port slots in the infra planner are different concepts), surface (a remote's ui/ssr loading surfaces are not remotes)
Registry key:
One of the four typed keys in src/services/registry/keys.ts (ADR 0040), each with one wire form: runtimeConfig (apps/<account>/<gateway>/bos.config.json), manifest (apps/<account>/<gateway>/manifest.json — the thin tag: version + digest), version (versions/<v>.json — the immutable per-release record, written once), deployRecord (deploys/<ts>.json — the audit trail). A RuntimeRef (bos://<account>/<gateway>) names the identity every key hangs from. Never hand-build registry paths.
Avoid: platform.json (the retired pre-cutover key — abandoned in place), slot (a key is not a slot), hand-built path strings (the golden tests pin the wire forms)
Platform release manifest:
The machine-readable contract of one framework release (ADR 0034): framework + every-plugin versions, the release catalog, exact shared-dep versions with their flags, the hashed template inventory, and the compat floor — composed once by the deploy train and published to two homes with byte-identical content (FastKV as the thin tag apps/<root-account>/<root-gateway>/manifest.json naming the immutable versions/<v>.json record — ADR 0040 — and the in-image copy generated inside the docker build). Carries image ref + tags, never the digest.
Avoid: version manifest (that's the per-workspace deploy pin), plugin manifest (the per-plugin bundle metadata), release notes
Derived release:
The child's single authored release: "<framework-version>" field in bos.app.ts — everything else (catalog entries, the deploy-time image ref ref@v<version> with its registry digest, the release-scoped sync source, compat verification) derives from the resolved manifest, so no hand-correlated pin pairs remain. Exact in v1: no ranges; absent means latest via extends. The old ci.image hand-pin is removed — a deploy fails fast on it.
Avoid: platform version (ambiguous with the manifest's own frameworkVersion), image pin (the digest is derived, not authored), version bump, platform pin (retired — the authored field is release:)
Runtime map:
The generated composition inventory (ADR 0034-adjacent, #591/#594) — every bos types gen run composes the ui sources (core, auth-ui, plugin UIs) with core-wins precedence and emits .bos/generated/runtime-map.json + ui/src/lib/runtime-map.gen.ts: mounts, every route with its owner and full path, shadowed claims, and the backend inventory (host, api, the auth server, plugin backends — remote ones carry the composed plugin version + contract hash from their published plugin.manifest.json). A static model of constructTree, kept honest by a parity test against the real engine. The first lookup for route/service ownership and local-vs-upstream classification (docs/agents/runtime-map.md); never grep node_modules.
Avoid: version manifest (that's the per-workspace deploy pin), plugin manifest (the per-plugin bundle metadata), route manifest (the per-ui-source input the map is composed from), composition report
Pin plane: One of the three independently-pinned byte sources a booting runtime consumes — image (the digest-pinned universal image), config (on-chain FastKV, account-key signed, atomic), bundles (CDN bytes whose sha384 SRI is recorded inside the on-chain config). The security model (ADR 0036): each plane's bytes verify against pins recorded in a different plane, so compromising any single plane is insufficient. Speed asymmetry is part of the model — config moves fast (atomic publish, minutes), image moves slow (rare smoke-gated rebuilds). Avoid: trust layer, security layer (nothing is layered — the planes are peers), integrity plane (integrity is one pin among three)
Release composition:
The version-scoped composition surface a release-authored runtime composes from (ADR 0034 consumer boot): every inherited remote — app.* and plugins.* — stamps at resolution with the authored release's recorded { production, digest } (ResolutionSession.releaseManifest → release-composition.ts), so production, local dev, and type generation all share one co-versioned byte set. Child-authored remotes stay untouched; remotes provisioned by later parent releases are omitted from an older release's composition and surfaced at dev boot ("present upstream from rc.N — run bos upgrade to inherit") rather than silently live-followed. bos upgrade is the release mover.
Avoid: version plane, release plane (retired), plane stamping (the mechanism; the release composition is the outcome), pointer-live (what it replaces: extends inheritance that drifted with the parent's latest deploy), remotes override (it is not a config source — it stamps the inherited entries)
Team: A named sub-group within an organization that shares access to the organization's feature areas. Avoid: team account, team wallet
Active Team: The Team currently selected for a user's organization work. Avoid: current team, team account
Feature Area: A product capability that an organization can grant to a Team. Avoid: permission, role
Team Workspace: The organization view scoped to an Active Team and its granted feature areas. Avoid: organization account
Statement:
A declared resource-to-actions entry in the permission catalog (email: ["read"]); the only things a role can grant. Undeclared means denied.
Avoid: permission (reserve for a statement:action pair), scope, binding
Role Grant:
The per-statement action grants a Role carries, declared in the runtime's siwn.permissions.roles config — the plugin ships no defaults.
Avoid: role permissions, role config
Effective Permissions:
The caller's resolved statement-to-actions map as of the request: session principals get their active organization's role grants, API-key principals get the key's declared permissions, anonymous callers get none. Surfaced by getContext and checked by requirePermission.
Avoid: permissions (unqualified, when you mean the resolved map), grants (when you mean the map)
Permission Registry: The runtime's normalized statements catalog plus role grants, built from config at boot and exposed as the auth plugin's registry service. Avoid: ACL, access list
Session Data Cookie: Better Auth's short-lived cookie cache of the session as of its last refresh; its team guards resolve the session from it, not from the database row. Writes that clear session state in the database strip it from the forwarded request so the guard re-reads the fresh row via the session token. Avoid: session cache, active-team cookie (say which state it caches)
Gateway Origin: The canonical base runtime origin for a network, where every passkey ceremony takes place regardless of which domain the member arrived from. Avoid: base URL, main domain
Device Link: Signing a desktop browser into an existing session by approving the desktop's QR code from a phone that is already signed in. Avoid: device pairing, sync, cross-device passkey (the browser-native hybrid flow is a different mechanism)
Stack:
The fixture a regression suite runs against: start (the production command — the host booted over locally built, statically served artifacts via bos start --config) or dev (the dev server, bos dev — smoke-covered only).
Avoid: environment (that's production/staging), target
Variant:
The render mode a stack runs with: ssr (server-composed) or csr (no ssr URL — the client composes). Written stack:variant (e.g. start:csr); a bare stack name runs both variants serially (test:regression:start / test:regression:dev).
Avoid: mode (reserved for production/staging env), project
Stall Watchdog: The Playwright reporter that fails the suite after minutes of zero test progress, printing a runner snapshot so a freeze produces evidence instead of eating the job timeout. Avoid: timeout (the job-level kill; the watchdog exists because that kill loses artifacts)
Gas Key: A NEAR access key (NEP-611) with its own prepaid gas balance and parallel nonce lanes; gas burns from the key's balance, not the account's. Avoid: prepaid key, allowance (a function-call key's allowance spends the account's own NEAR — a different mechanism)
Session Gas Key:
The browser-generated Gas Key scoped to the FastKV namespace's __fastdata_kv method, bootstrapped onto a user's account at their opt-in and used to sign platform writes locally.
Avoid: session key, FCAK, gas key (that's the protocol concept — be specific about which)
Sponsor:
The funding role of the ephemeral relayer account: it tops up Session Gas Keys via TransferToGasKey under server-enforced per-user caps.
Avoid: relayer for this role (the relayer is the NEP-366 role of the same account — say which you mean)
Bootstrap:
The one-time, wallet-signed AddKey transaction that installs a Session Gas Key on the user's account; refused for wallets whose manifest lacks features.gasKeys.
Avoid: provision, register
Lane: One of a Gas Key's independent nonce sequences; parallel sends pick different Lanes and never serialize on each other. Avoid: nonce (the per-lane counter), slot
Agent Account:
A custody account on NEAR Intents owned by a signed-in user and driven by AI agents under the owner-signed policy; the auth plugin maps one Better Auth user to their Agent Accounts (agentAccount).
Avoid: agent wallet (that's the custody Wallet inside it), bot account
Owner Intent:
One owner-authorized change to an Agent Account (create, policy, grant, freeze, delete) — generated by the backend, signed by the owner's wallet byte-for-byte, then submitted; tracked per user in ownerIntent by Correlation Id.
Avoid: transaction (on-chain only for some intents), action (that's a policy permission)
Grant Token:
The revocable ngt_… credential letting one agent session act on an Agent Account inside the policy; the server stores it encrypted at rest and it never reaches a browser or model.
Avoid: API key (the partner's naa_ credential — different party), session token
Correlation Id:
The tracking id of one Owner Intent or execution (intent_…/op_…); the ledger authorizes submits and status reads against it.
Avoid: operation id generically, request id (that's the API's meta.request_id)
Custody Wallet:
An OutLayer Agent Custody wallet (wk_… key, TEE-held keys) registered once per user and network during bos login --custody; its implicit hex account is the signing identity for publish.auth = "custody" publishes.
Avoid: outlayer credential, agent wallet (say custody)
Machine identity:
The custody wallet's implicit hex account as the deploy target: the authored config's account must equal it, so configs publish under apps/<hex-account>/<gateway> instead of a named account.
Avoid: bot account (not a named account), executor (OutLayer's own term for something else)
Hosting adapter: The platform's only seam for operating runtime instances — deploy an image with identity env, report what is running, restart, stop. Substrate implementations (Docker, Railway, Fly) hide behind it; swapping substrate is a wiring change. Avoid: provider (Alchemy's own term for its resource kits — say which), deploy leg (a train stage, not the seam)
Deploy console: The root app surface that lists deploys from on-chain audit manifests and drives rollback and log investigation for the root and every child. Avoid: dashboard, admin panel, hosting UI
Rollback unit: The whole of a console rollback, FastKV-first: re-publish the previous verified snapshot (config + manifest pins, SRI-checked, refused outright on failure), then restart the instance against the rolled-back pin. Shared-host tenants get the config half only — per-request resolution makes it instant. Avoid: redeploy (the instance half alone), image rollback (implies the image is the unit)
Reconciler: The platform-side watcher that converges platform-hosted instances to each namespace's latest published pointer digest — making publish the deploy action. Idempotent; failures surface as drift. Avoid: relay, agent, deploy trigger
Digest identity:
The two composition-plane hashes (ADR 0046 ticket 04), both derived in everything-dev/digest so the planes can't drift: pointer digest (what is pinned — a hash over every remote's pin coordinates; the lockfile's identity per ADR 0042, the watch's change-detection hash, what deployment records name) and deployment digest (what is served — the pointer inputs plus resolved entry coordinates per slot; the client soft-refresh signal and the host's adopt comparison). Relation: pointer stable + entries stable ⇒ deployment stable; the converse is deliberately not a guarantee — adopt treats an unchanged deployment digest as skip (a heuristic), and the watch tracks the pointer independently. Species, never compared across: content digests (the engine's Digest SRI brand, version id/dirId), the compose digest (SSR/client parity), the lockfile digest (serialized content), the compose variant cache key (dev mtimes — a cache key, not an identity).
Avoid: fingerprint (retired word — pre-cutover lockfiles/snapshots/records carry fingerprint fields and are regenerated on next bos lock / first adopt; the old everything-dev/fingerprint subpath is removed), hash (never says what is hashed)
Sync baseline (template.sync):
The per-file template hash record bos sync's three-way comparison reads (ADR 0047) — committed as the optional template.sync section of bos.lock.json, with .bos/sync-snapshot.json as the lock-less fallback and the migration's absorb source. A local annotation on the lock: never produced by lockfileOf, never enters the pointer or lockfile digest, carried forward by every writer. Missing baseline + local divergence ⇒ conflicted, never a silent template win.
Avoid: snapshot (ambiguous — the boot snapshot and the legacy sync-snapshot file are different artifacts; say "sync baseline" or "boot snapshot"), lock (the lock is the whole file; the baseline is one section)
Verification spine: The chain tx → config → release record → slot manifest → version dir → file sequence of attestations from the on-chain write to the served byte (ADR 0046). Each layer edge is independently checked — the registry write is NEAR-signed, the config's pins carry manifest SRIs, the release record is immutable, the manifest pins the entry and maps every file's SRI, the version dir is content-addressed, files hash to their SRIs — and every consumer re-verifies the prefix it loads through: the Verifier engine is the primitive, the chain walker walks all depths, and the smoke/adopt legs refuse a broken prefix instead of serving past it. Avoid: trust chain (implies transitive trust — nothing is inherited; each hop is checked on its own), integrity chain (integrity is one property the spine carries; it also carries provenance and attribution)
Attestation: One identity-bytes-digest claim at a layer edge of the spine — these bytes, at this layer, hash to this digest, per this identity. The walker reports each leg separately; an attestation fails loud and named, never degrades to a warning. Avoid: signature (reserved for the cryptographic kind — the manifest attribution, ADR 0046)
Verified<T>:
A branded artifact that has passed the Verifier engine — bytes whose digest matched the pin at fetch time, a parsed document whose SRI verified. Consumers take Verified<T> and unverified bytes don't flow: the type is the gate, mark is the only door, and every production fetch path goes through the engine.
Avoid: checked value, SRI'd value (informal — the brand is the term)
Attribution: The cryptographic "published by the runtime's identity" property signatures add on top of integrity (ADR 0046): the deploy train signs each slot's version manifest with the existing publish identity, and the verifying key record publishes inside the on-chain config — so the record inherits chain authenticity and rotation is a config publish, never a silent key swap. Avoid: authentication of bytes (overloaded — sessions authenticate, bytes are attributed), trust (the property exists so you don't need it)
Drift:
The served/live state diverging from a published pin — the umbrella term whose byte-level form is rot (a served object no longer hashes to its pin) and whose release-level form is staleness (the served generation behind the published pointer). The pointer watch converges it; the smoke gate, the adopt comparison, and bos verify detect it.
Avoid: skew (reserve for generation mixing inside one load — the compose digest parity check)
Fleet: The set of runtime instances the platform hosts on its own managed substrate — the root pair, own-instance children, and sandbox leases. Avoid: cluster (carries Kubernetes connotations we rejected), infra (too broad)
Secrets vault:
The per-deployment store of sealed runtime secrets in the api shell — keyed (account, gateway, name), sealed with the proven sealed-box cipher under a per-runtime KEK. Values are never echoed back; each deployment keeps its own vault (a single global one would be a trust disaster).
Avoid: KMS (implies an external service), .env (the vault's whole point is not needing one), secret manager
KEK (key-encryption key):
The per-runtime AES key that seals a runtime's secrets — HKDF'd from the platform root secret (BETTER_AUTH_SECRET) with a runtime-scoped salt. Its source is a swappable sub-seam: the custody-TEE swap (ticket 13) changes where the KEK comes from without touching the schema, CLI, or config declarations.
Avoid: root key (that's the platform secret the KEK derives from), master key
Call-only plugin:
A plugins.<key> attachment authored with proxy + contract (+ optional secrets) and none of the composed source fields (extends, path, URL fields) — it consumes a deployed app's API as a typed oRPC client without federation-loading its bundle, composing its routes, or running its services. Detection is structural: proxy present, no source. The entry stays a regular plugin entry in every other respect.
Avoid: rpc-mode (the superseded discriminator — removed), remote plugin (that's a composed federation remote), proxy-only (proxy alone is the traffic endpoint, not the concept)
Contract locator:
The call-only attachment's contract value — a bos://account/gateway[#target] ref whose targeted entry's stamped production is the artifact CDN origin serving the sha256-verified contract types. A pure type pointer: it merges nothing, adopts no UI, and never touches composable-entry resolution. Distinct origin from the traffic endpoint in production — that split is why call-only has two locators.
Avoid: extends (that composes the targeted entry — merging, UI adoption, pins), types URL (the locator is a ref, not a URL)
Call-only proxy endpoint:
The attachment's proxy value — the live app origin whose /api/rpc serves the plugin's traffic. The host forwards /api/rpc/{key}/* to it with the declared secret as x-api-key (server-side only), through the same dispatch seam as composed-plugin routers; readiness probes its rpc ping, because a manifest-200 from the artifact CDN says nothing about whether the API serves.
Avoid: contract origin (the CDN serving types — the other locator), reverse proxy (uncharged term)