basalt-ui 1.41.0 → 2.0.1

package/src/tokens/palette.ts

@@ -31,7 +31,7 @@
 
 import { DEFAULT_DERIVE_CONFIG, deriveTokens, isDefaultDeriveConfig } from './derive'
 import type { DeriveConfig } from './derive'
-import type { ColorPair } from './index'
+import type { ColorPair } from './core'
 
 /**
  * Basalt palette. Each family is shade 1→5 (index 0 = darkest, 4 = lightest).
@@ -703,15 +703,12 @@ const SPACE_STEP_BASE = {
   // `VX.lineWidth`/`VX.line2Width` are DELIBERATELY absent here — they are stroke WEIGHTS (line
   // thickness), not spacing/gaps/sizes, so they stay fixed regardless of density (see `VX` in
   // `tokens/index.ts`). The six below are gaps/margins/a marker footprint — genuinely spacing.
-  /** `ChartLegend`'s column/row gap (`VX.legendGap`). */
+  /** The chart legend's column gap (`VX.legendGap`). */
   chartLegendGap: 22,
   /** Chart plot-area margin, top (`VX.margin.top`). */
   chartMarginTop: 12,
   /** Chart plot-area margin, right (`VX.margin.right`). */
   chartMarginRight: 16,
-  /** Minimum right margin when an `AxisRightNumeric` is rendered — labels like "100"/"60m" need
-   * more room than the no-right-axis default (`chartMargin({ rightAxis: true })`, `tokens/index.ts`). */
-  chartMarginRightAxis: 40,
   /** Chart plot-area margin, bottom (`VX.margin.bottom`). */
   chartMarginBottom: 30,
   /** Chart plot-area margin, left (`VX.margin.left`). */
@@ -1205,8 +1202,7 @@ function buildPaletteDataUncached(config: DeriveConfig) {
   const inkLight = DERIVED.ink.ink.light
 
   /**
-   * Theme-resolved neutrals (line / axis / grid / tooltip chrome). Mirrors the old
-   * useVxTheme() outputs, retuned to the zinc identity.
+   * Theme-resolved neutrals (line / axis / grid / tooltip chrome), retuned to the zinc identity.
    */
   const NEUTRAL = {
     line: { light: BP.gray[0], dark: BP.gray[4] }, // primary line

package/src/vite.ts

@@ -25,7 +25,7 @@ import type { HtmlTagDescriptor, Plugin, PluginOption, UserConfig } from 'vite'
 import { SURFACE } from './tokens/palette'
 import { resolveColorMix } from './vite-color-mix'
 
-export type BasaltViteOptions = {
+type BasaltViteOptions = {
   /** Dev server port. Passed with `strictPort: true` so the app fails fast on a busy port. */
   port: number
   /** Dev server host (bind address, or `true` to listen on all interfaces). */
@@ -206,7 +206,7 @@ const ICON_FILES = {
  * `site.webmanifest`. `src` is root-relative (`'/favicon.svg'` or `'favicon.svg'`, both resolve the
  * same) and is prefixed with Vite's `base` exactly like basalt's built-in set.
  */
-export type BasaltAppIcon = {
+type BasaltAppIcon = {
   /** Root-relative path under `public/`. Prefixed with Vite's resolved `base`. */
   src: string
   /** Manifest `sizes`. `'any'` for a scalable SVG; `'192x192'` for a raster. */
@@ -222,7 +222,7 @@ export type BasaltAppIcon = {
   rel?: 'icon' | 'shortcut icon' | 'apple-touch-icon' | 'mask-icon'
 }
 
-export type BasaltAppOptions = {
+type BasaltAppOptions = {
   /** App display name — used verbatim as the manifest `name` and (unless overridden) OG title. */
   name: string
   /** Short name for home-screen labels. Default: `name`. */

package/agent/templates/query-client.ts.tpl

@@ -1,26 +0,0 @@
-/**
- * Basalt query client — configure once, share via router context.
- * Extend staleTime / gcTime defaults and add per-query error handling here.
- *
- * A FACTORY, not a module-level singleton, and that is load-bearing under SSR: a
- * `export const queryClient = createBasaltQueryClient()` is created once per PROCESS,
- * so every request a Node server handles shares one cache — one user's data served to
- * the next. Call `makeQueryClient()` once per request on the server, and once at module
- * scope in a browser-only entry:
- *
- *   // main.tsx (CSR) — one client for the tab's lifetime
- *   const queryClient = makeQueryClient()
- *
- *   // an SSR/prerender entry — one per request, never hoisted
- *   const queryClient = makeQueryClient()
- *
- * Scaffold written by `basalt-ui init`. This file is yours — `basalt-ui sync` will not overwrite it.
- */
-import { createBasaltQueryClient } from 'basalt-ui'
-
-export function makeQueryClient() {
-  return createBasaltQueryClient({
-    // staleTime: 60_000,   // optional: global cache freshness window (ms)
-    // gcTime: 5 * 60_000,  // optional: inactive-query garbage-collection window (ms)
-  })
-}

package/dist/agent/adapter.d.ts

@@ -1,150 +0,0 @@
-import type { ChatMessage } from './history.js';
-import type { AgentOutcome } from './outcome.js';
-import type { AgentPart } from './parts.js';
-import type { AgentThread, ThreadStatus, ThreadsStore } from './thread.js';
-/**
- * The async persistence contract behind a `ThreadsStore`. Every method may reject; the wrapping
- * store treats a rejection as "the optimistic edit did not happen" and rolls it back.
- *
- * Implement this against whatever owns the transcript (Postgres, an HTTP API, IndexedDB) and
- * verify it with `threadsStoreAdapterContract` — the suite pins the parts of the contract that
- * prose cannot enforce, chiefly `appendMessage`'s idempotency.
- *
- * ## What `createAdapterThreadsStore` guarantees you
- *
- * **Per-thread write ordering.** Writes carrying the same thread id reach this adapter strictly in
- * issue order, each one awaiting the previous, so a write that depends on a row existing is never
- * issued before that row's `createThread` has RESOLVED. This matters because the primary send path
- * is one synchronous block — `create()`, `select()`, `markRead()`, `appendMessage()`,
- * `setStatus()` — which without ordering would hand you three dependent writes against a row you
- * have not created yet. You therefore never have to tolerate (or invent an upsert for) an
- * out-of-order write. Writes for DIFFERENT thread ids stay concurrent and carry no ordering
- * guarantee relative to each other.
- *
- * ## What it requires of you
- *
- * **Read-after-write consistency on `listThreads`.** A `listThreads` STARTED after a write has
- * resolved must reflect that write. The store keeps a write's optimistic patch applied until such
- * a list lands, then drops it; an eventually-consistent backend (a stale read replica, a cached
- * list) will therefore flash the pre-write state back into the UI. `threadsStoreAdapterContract`
- * pins this.
- *
- * @example
- * const postgresThreadsAdapter = (api: Api): ThreadsStoreAdapter => ({
- *   listThreads: (signal) => api.threads.get({ fetch: { signal } }),
- *   loadThread: (id, signal) => api.threads({ id }).get({ fetch: { signal } }),
- *   createThread: ({ id, meta }) => api.threads.post({ id, meta }),
- *   // ...
- * })
- */
-export type ThreadsStoreAdapter<TPart = AgentPart> = {
-    /** All threads, NEWEST-FIRST (same ordering contract as `ThreadsStore.threads`). */
-    readonly listThreads: (signal?: AbortSignal) => Promise<readonly AgentThread<TPart>[]>;
-    /** One thread by id, or `null` when it does not exist. Must not throw on an unknown id. */
-    readonly loadThread: (id: string, signal?: AbortSignal) => Promise<AgentThread<TPart> | null>;
-    /**
-     * Materialize a new thread under the CLIENT-MINTED `id`. The id is minted client-side because
-     * `ThreadsStore.create()` returns synchronously — there is no await to hand a server id back
-     * through. The created thread starts empty: `messages: []`, `outcome: null`,
-     * `status: 'pending'`, `read: false`, with `createdAt`/`updatedAt` set.
-     */
-    readonly createThread: (i: {
-        readonly id: string;
-        readonly meta?: Record<string, unknown>;
-    }) => Promise<void>;
-    /**
-     * CONTRACT: idempotent on `message.id`. The id is client-minted and is the ONLY idempotency
-     * key — a retried or double-fired write with the same id must be a no-op, not a second row.
-     */
-    readonly appendMessage: (i: {
-        readonly threadId: string;
-        readonly message: ChatMessage<TPart>;
-    }) => Promise<void>;
-    readonly setStatus: (i: {
-        readonly threadId: string;
-        readonly status: ThreadStatus;
-    }) => Promise<void>;
-    readonly setOutcome: (i: {
-        readonly threadId: string;
-        readonly outcome: AgentOutcome;
-    }) => Promise<void>;
-    /** `token: undefined` CLEARS the token — the stored thread must then read `resumeToken` as absent. */
-    readonly setResumeToken: (i: {
-        readonly threadId: string;
-        readonly token: string | undefined;
-    }) => Promise<void>;
-    readonly markRead: (threadId: string) => Promise<void>;
-    /** Removing an unknown id is a no-op, not an error. */
-    readonly removeThread: (threadId: string) => Promise<void>;
-};
-export type AdapterThreadsStoreOptions = {
-    /**
-     * Re-list threads whenever the window regains focus. Off by default — a background tab that
-     * refocuses should not surprise a consumer with a network round-trip it did not ask for.
-     * @default false
-     */
-    readonly revalidateOnFocus?: boolean;
-};
-/**
- * Wraps an async `ThreadsStoreAdapter` into the synchronous `ThreadsStore` every component takes.
- *
- * Call this ONCE per module (not inside a component), exactly like `createThreadsStore`. All
- * components calling the returned hook share one registry, backed by `useSyncExternalStore`.
- *
- * Semantics:
- * - **Optimistic.** Every mutation applies locally first, so `create()` can return an id
- *   synchronously and the UI never waits on a round-trip.
- * - **Ordered per thread.** Writes for one thread id reach the adapter in issue order, each
- *   awaiting the previous — so the dependent writes of a `create()`-then-send land after
- *   `createThread` has resolved. Different threads stay concurrent. See `ThreadsStoreAdapter`.
- * - **Revalidate on success, coalesced.** When a write resolves the store re-lists; the patch is
- *   dropped only once a list has actually refreshed the confirmed base, so server-side derivations
- *   win over the local guess with no gap in between. Writes that resolve while a list is already in
- *   flight share ONE follow-up instead of each restarting it, so a burst of writes costs at most
- *   two round trips (the in-flight one, plus one follow-up), not one per write — see `revalidate`.
- * - **Roll back on rejection.** A rejected write's patch is discarded, the rejection is surfaced
- *   on `error`, and the store re-lists to converge on whatever the server really did. Patches are
- *   tracked individually, so a failing write rolls back only itself and not whatever else was in
- *   flight beside it. A rejected `create()` additionally drops every later single-thread write for
- *   that id (`markRead`/`appendMessage`/`setStatus`/… — both the ones chained directly behind it and
- *   the run's completion writes at stream end) instead of letting each fail independently against a
- *   row that no longer exists — see `failedCreateIds`. Without that, the create's own error is
- *   overwritten by a run of "unknown thread" rejections that name nothing a caller can act on.
- * - **`hydrated` means "a `listThreads` has succeeded"**, not "a load has been attempted". A
- *   store that is `!hydrated` with a non-undefined `error` failed to load; check both.
- * - **`error` latches the most recent failure until something disproves it.** A successful
- *   `listThreads` clears a LOAD failure; it leaves a WRITE failure alone, since a working list is
- *   no evidence the rejected write landed. A write clears a latched write failure only if it was
- *   issued after that failure (a retry) — never the writes that were already queued behind it.
- *
- * `select` is local-only — which thread is active is UI state, not something the adapter owns.
- * `clear()` maps onto `removeThread` for each known thread, since the adapter has no bulk delete.
- *
- * @example
- * export const useThreads = createAdapterThreadsStore(myAdapter, { revalidateOnFocus: true })
- */
-export declare function createAdapterThreadsStore<TPart = AgentPart>(adapter: ThreadsStoreAdapter<TPart>, opts?: AdapterThreadsStoreOptions): () => ThreadsStore<TPart>;
-/** One conformance case. `run` rejects with a plain Error describing the violation. */
-export type ThreadsStoreAdapterContractCase = {
-    readonly name: string;
-    readonly run: () => Promise<void>;
-};
-/**
- * A test-runner-agnostic conformance suite for a `ThreadsStoreAdapter` implementation.
- *
- * This ships in the published package, so it deliberately imports NO test framework and depends
- * on no assertion library — each case throws a plain `Error`. Drive it from whatever runner the
- * consumer uses.
- *
- * `makeAdapter` is called ONCE PER CASE and must hand back a fresh, empty backend: the cases are
- * independent and none of them cleans up after itself.
- *
- * @example
- * import { threadsStoreAdapterContract } from 'basalt-ui/agent'
- *
- * for (const c of threadsStoreAdapterContract(() => postgresThreadsAdapter(freshDb()))) {
- *   test(c.name, () => c.run())
- * }
- */
-export declare function threadsStoreAdapterContract<TPart>(makeAdapter: () => ThreadsStoreAdapter<TPart> | Promise<ThreadsStoreAdapter<TPart>>): readonly ThreadsStoreAdapterContractCase[];
-//# sourceMappingURL=adapter.d.ts.map

package/dist/agent/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/agent/adapter.ts"],"names":[],"mappings":"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"}