wiki-formant 0.56.0 → 0.57.1

package/README.md

@@ -916,9 +916,15 @@ straight between closes and a count's is curved.
 
 `aggregate` is how a week or month is made from its days: `last` for a price,
 `mean` for a count, so the week in progress keeps its level instead of reading
-as a collapse. A single range draws no range buttons and shows every point.
+as a collapse. `fromZero` starts a count's axis at zero and stops it there, with
+no negative ticks under it. A single range draws no range buttons and shows every point.
 `chartSteps` is exported for a chart drawn elsewhere.
 
+`format` writes the axis and the crosshair label. An axis tick also gets the
+spacing between ticks as a second argument, so a formatter can write every tick
+to the same precision and two never read alike: `stepDecimals(step)` is the
+decimal places that takes, and `formatChartValue`, the default, uses it.
+
 `markers` are events, `{ time, label }`, each drawn as an arrow on the last
 point at or before it, so one mid-week lands on its week and two on one point
 share it. `step` opens on a step where the
@@ -1021,10 +1027,11 @@ An app that keeps one schema file and writes the models into it by hand, because
 npx prisma-models analytics --check --in prisma/schema.prisma --tenant   # miow
 ```
 
-`fts-ddl <table>` rebuilds a table's `search_tsv` generated column and its GIN index from the expression `wiki-formant/search` queries, over `DIRECT_URL` (else `DATABASE_URL` on 5432). Run it before declaring the column in `schema.prisma`; the bin's header says why.
+`fts-ddl <table>` rebuilds a table's `search_tsv` generated column and its GIN index from the expression `wiki-formant/search` queries, over `DIRECT_URL` (else `DATABASE_URL` on 5432). Run it before declaring the column in `schema.prisma`; the bin's header says why. A PascalCase Prisma table goes in quoted, as SQL names it.
 
 ```sh
 npx fts-ddl pages
+npx fts-ddl '"WikiPage"'
 ```
 
 `mark-verified` stamps `last_verified_at` on pages a sweep checked and found current, so `freshnessBanner` stops calling them outdated, and `maintenance-log` is the state I/O of a wiki-sweep routine whose memory lives in one page's `metadata.state`: `read`, `write` (the whole state, or `-` for stdin), `compact` and `backlog-add`, which appends under a row lock so another routine's item cannot be lost to a concurrent `write`. Every write compacts and re-renders the page, holding at most as many FLAG FOR A HUMAN items as the page shows; a revision is written at most once a day. `write` refuses a state whose `totalRuns` is below the stored one, which is a state read before another run wrote. Two wikis carried both scripts against their own tables, so the tables are arguments. Run them from the app's root, like `passkey-invite`:

package/bin/fts-ddl.mjs

@@ -8,6 +8,7 @@
 //
 //   npx fts-ddl pages
 //   npx fts-ddl wiki_pages
+//   npx fts-ddl '"WikiPage"'
 //
 // The column is rebuilt every run rather than skipped when it exists: a skip
 // is blind to a changed EXPRESSION, and Postgres normalises the stored one, so
@@ -32,7 +33,7 @@ import { searchTsvDdl } from '../dist/search.js';
 import { connect } from './_cli.mjs';
 
 const table = process.argv[2];
-if (!table || !/^[a-z_][a-z0-9_]*$/.test(table)) {
+if (!table || !/^([a-z_][a-z0-9_]*|"[A-Za-z_][A-Za-z0-9_]*")$/.test(table)) {
   console.error('usage: npx fts-ddl <table>');
   process.exit(1);
 }
@@ -43,6 +44,7 @@ const client = await connect({ direct: true, ssl: { rejectUnauthorized: false },
   process.exit(1);
 });
 const q = s => client.query(s).then(r => r.rows);
+const bare = table.replaceAll('"', '');
 try {
   const ddl = searchTsvDdl(table);
   await q('BEGIN');
@@ -52,9 +54,9 @@ try {
   await q(ddl.index);
   console.log('GIN index present');
   console.table(await q(`select column_name, data_type, is_generated from information_schema.columns
-    where table_name='${table}' and column_name='search_tsv'`));
+    where table_name='${bare}' and column_name='search_tsv'`));
   console.table(await q(`select count(*)::int rows, count(*) filter (where search_tsv is null)::int null_tsv from ${table}`));
-  console.table(await q(`select pg_size_pretty(pg_relation_size('${table}_search_tsv_idx')) index_size`));
+  console.table(await q(`select pg_size_pretty(pg_relation_size('"${bare}_search_tsv_idx"')) index_size`));
 } catch (e) {
   await q('ROLLBACK').catch(() => {});
   console.error(e.message);

package/dist/chart.d.ts

@@ -35,8 +35,13 @@ export declare function chartSteps(span: number): {
     steps: ChartStep[];
     fallback: ChartStep;
 };
-/** Compact from a thousand up, four significant figures below. */
-export declare const formatChartValue: (n: number) => string;
+/** The decimal places that write every multiple of `step` exactly: two for 0.25, none for 5000. */
+export declare function stepDecimals(step: number): number;
+/**
+ * Compact from a thousand up, four significant figures below. An axis tick is
+ * written to its step in the unit it reads in, so 4.845B is not a second 4.85B.
+ */
+export declare function formatChartValue(n: number, step?: number): string;
 export interface TimeChartProps {
     /** Daily points, oldest first, or a loader for every resolution the ranges need. */
     series: readonly ChartPoint[] | ChartLoader;
@@ -50,8 +55,11 @@ export interface TimeChartProps {
     aggregate?: 'last' | 'mean';
     /** The value axis starts at zero, so a quiet week does not read as a collapse. */
     fromZero?: boolean;
-    /** The value axis and crosshair label. Read on every draw, so it need not be stable. */
-    format?: (n: number) => string;
+    /**
+     * The value axis and crosshair label. Read on every draw, so it need not be stable.
+     * An axis tick passes the spacing between ticks, so neighbours never read alike.
+     */
+    format?: (n: number, step?: number) => string;
     /** Open on candles, where the points carry them. A candles toggle shows either way. */
     candles?: boolean;
     /** In pixels. Otherwise the stylesheet's `--chart-height`, else 15rem. */

package/dist/chart.js

@@ -103,10 +103,25 @@ export function placeMarkers(markers, shown, step) {
     return [...placed].map(([time, labels]) => ({ time, label: labels.join(' · ') }));
 }
 const isCandle = (p) => p.open !== undefined && p.high !== undefined && p.low !== undefined;
+/** The decimal places that write every multiple of `step` exactly: two for 0.25, none for 5000. */
+export function stepDecimals(step) {
+    const exponent = Math.floor(Math.log10(step));
+    // The axis steps by 1, 2, 2.5 or 5 times a power of ten; rounding drops float noise.
+    const mantissa = String(Math.round((step / 10 ** exponent) * 1e6) / 1e6);
+    return Math.min(20, Math.max(0, (mantissa.split('.')[1]?.length ?? 0) - exponent));
+}
 const compact = new Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: 2 });
 const precise = new Intl.NumberFormat('en', { maximumSignificantDigits: 4 });
-/** Compact from a thousand up, four significant figures below. */
-export const formatChartValue = (n) => (Math.abs(n) >= 1e3 ? compact.format(n) : precise.format(n));
+/**
+ * Compact from a thousand up, four significant figures below. An axis tick is
+ * written to its step in the unit it reads in, so 4.845B is not a second 4.85B.
+ */
+export function formatChartValue(n, step) {
+    if (step === undefined)
+        return Math.abs(n) >= 1e3 ? compact.format(n) : precise.format(n);
+    const unit = Math.abs(n) >= 1e3 ? 1e3 ** Math.min(4, Math.floor(Math.log10(Math.abs(n)) / 3)) : 1;
+    return new Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: stepDecimals(step / unit) }).format(n);
+}
 /**
  * A CSS colour at an opacity, as the rgba() the chart's parser reads. Drawn to
  * a pixel and read back, because a site's colour may be oklch() or a named one.
@@ -119,12 +134,16 @@ function rgba(colour, alpha = 1) {
     ctx.fillRect(0, 0, 1, 1);
     return `rgba(${Array.from(ctx.getImageData(0, 0, 1, 1).data.slice(0, 3)).join(', ')}, ${alpha})`;
 }
+// A count's axis starts at zero and stops there: the scale's bottom margin is off and
+// a few pixels below zero hold its label, where a margin would draw negative ticks.
 const fromZeroScale = (base) => {
     const info = base();
     if (info?.priceRange)
         info.priceRange.minValue = 0;
-    return info;
+    return info && { ...info, margins: { above: info.margins?.above ?? 0, below: 8 } };
 };
+const ownScale = (base) => base();
+const MARGIN_TOP = 0.15;
 /**
  * A time series with its range, step and style buttons. The buttons are
  * `.chart-controls button[aria-pressed]`, and a site's stylesheet gives them
@@ -156,7 +175,17 @@ export function TimeChart({ series, label, ranges = typeof series === 'function'
             const ink = rgba(style.color);
             const up = rgba(style.getPropertyValue('--chart-up').trim() || style.color);
             const down = rgba(style.getPropertyValue('--chart-down').trim() || style.color, style.getPropertyValue('--chart-down').trim() ? 1 : 0.45);
-            const priceFormat = { type: 'custom', formatter: (n) => formatRef.current(n), minMove: 1e-12 };
+            const priceFormat = {
+                type: 'custom',
+                formatter: (n) => formatRef.current(n),
+                // Ticks are evenly spaced, so the gap between any two is the step. Each is snapped to
+                // it, since the library's zero can arrive as -1e-18.
+                tickmarksFormatter: (ticks) => {
+                    const step = ticks.length > 1 ? Math.abs(ticks[0] - ticks[1]) : 0;
+                    return ticks.map(n => (step ? formatRef.current(Math.round(n / step) * step, step) : formatRef.current(n)));
+                },
+                minMove: 1e-12,
+            };
             const guide = { color: rgba(style.color, 0.4), width: 1, style: LineStyle.Dotted, labelBackgroundColor: ink };
             const grid = rgba(axis || style.color, 0.1);
             const api = createChart(el, {
@@ -171,8 +200,9 @@ export function TimeChart({ series, label, ranges = typeof series === 'function'
                 },
                 grid: { vertLines: { color: grid }, horzLines: { color: grid } },
                 crosshair: { mode: CrosshairMode.Magnet, vertLine: guide, horzLine: guide },
-                rightPriceScale: { borderVisible: false, scaleMargins: { top: 0.15, bottom: 0.1 } },
-                timeScale: { borderVisible: false, secondsVisible: false },
+                rightPriceScale: { borderVisible: false },
+                // The value axis settles its width after the points are fitted; the range holds through it.
+                timeScale: { borderVisible: false, secondsVisible: false, lockVisibleTimeRangeOnResize: true },
                 handleScroll: false,
                 handleScale: false,
             });
@@ -181,11 +211,9 @@ export function TimeChart({ series, label, ranges = typeof series === 'function'
                 topColor: rgba(style.color, 0.4),
                 bottomColor: rgba(style.color, 0.02),
                 lineWidth: 2,
-                lineType: aggregate === 'mean' ? LineType.Curved : LineType.Simple,
                 crosshairMarkerBackgroundColor: ink,
                 crosshairMarkerBorderColor: ink,
                 priceFormat,
-                ...(fromZero && { autoscaleInfoProvider: fromZeroScale }),
             });
             const candle = api.addSeries(CandlestickSeries, {
                 visible: false,
@@ -209,6 +237,7 @@ export function TimeChart({ series, label, ranges = typeof series === 'function'
             };
             chart.current = {
                 api, area, candle, volume: null, addVolume, up, down, ink,
+                curved: LineType.Curved, straight: LineType.Simple,
                 areaMarkers: createSeriesMarkers(area, []),
                 candleMarkers: createSeriesMarkers(candle, []),
             };
@@ -220,7 +249,15 @@ export function TimeChart({ series, label, ranges = typeof series === 'function'
             chart.current = null;
             setReady(false);
         };
-    }, [fromZero, aggregate]);
+    }, []);
+    // Applied to the chart in place: rebuilding it would leave a new chart with nothing drawn on it.
+    useEffect(() => {
+        const c = chart.current;
+        if (!ready || !c)
+            return;
+        c.api.priceScale('right').applyOptions({ scaleMargins: { top: MARGIN_TOP, bottom: fromZero ? 0 : 0.1 } });
+        c.area.applyOptions({ lineType: aggregate === 'mean' ? c.curved : c.straight, autoscaleInfoProvider: fromZero ? fromZeroScale : ownScale });
+    }, [ready, fromZero, aggregate]);
     // One request per resolution for the life of the loader: every range from 30D up reads the same days.
     const cache = useRef(new Map());
     useEffect(() => {

package/dist/search.d.ts

@@ -2,8 +2,11 @@
  * Every `text` value at any block depth, as prose.
  *
  * `$.**.text` rather than the raw JSON, so block ids and `type` discriminators
- * cannot score as prose. Then three classes of non-prose are collapsed to
- * spaces:
+ * cannot score as prose. In strict mode: lax, Postgres' default, unwraps each
+ * array `.**` meets and visits its elements twice, so every value came out
+ * twice — measured on all 624 miow pages in October 2026, doubling snippets and
+ * every lexeme in `search_tsv`. `silent` keeps strict from raising on items
+ * with no `text`. Then three classes of non-prose are collapsed to spaces:
  *
  *   - markup (`<[^>]*>`) and the `&nbsp;` entity
  *   - the JSON array literal's own syntax — `", "` between adjacent values,
@@ -32,6 +35,9 @@ export declare function proseSql(content?: string): string;
  * rebuilds. The column is derived from `content`, so dropping it loses nothing.
  * Run it BEFORE declaring the column in a Prisma schema: `prisma db push` reads
  * a generated column it does not know about as drift and drops it.
+ *
+ * @param table the table as SQL names it: `pages`, or `"WikiPage"` for a
+ *              PascalCase Prisma model, whose index is `"WikiPage_search_tsv_idx"`.
  */
 export declare function searchTsvDdl(table: string, { content, title }?: {
     content?: string;

package/dist/search.js

@@ -25,8 +25,11 @@
  * Every `text` value at any block depth, as prose.
  *
  * `$.**.text` rather than the raw JSON, so block ids and `type` discriminators
- * cannot score as prose. Then three classes of non-prose are collapsed to
- * spaces:
+ * cannot score as prose. In strict mode: lax, Postgres' default, unwraps each
+ * array `.**` meets and visits its elements twice, so every value came out
+ * twice — measured on all 624 miow pages in October 2026, doubling snippets and
+ * every lexeme in `search_tsv`. `silent` keeps strict from raising on items
+ * with no `text`. Then three classes of non-prose are collapsed to spaces:
  *
  *   - markup (`<[^>]*>`) and the `&nbsp;` entity
  *   - the JSON array literal's own syntax — `", "` between adjacent values,
@@ -43,7 +46,7 @@
  *                when the query aliases its table.
  */
 export function proseSql(content = 'content') {
-    return `regexp_replace(translate(jsonb_path_query_array(${content},'$.**.text')::text, chr(160),' '),'${PROSE_PATTERN}',' ','g')`;
+    return `regexp_replace(translate(jsonb_path_query_array(${content},'strict $.**.text','{}',true)::text, chr(160),' '),'${PROSE_PATTERN}',' ','g')`;
 }
 /**
  * The `regexp_replace` pattern inside {@link proseSql}, as it must appear in
@@ -76,6 +79,9 @@ export function searchTsvSql(content = 'content', title = 'title') {
  * rebuilds. The column is derived from `content`, so dropping it loses nothing.
  * Run it BEFORE declaring the column in a Prisma schema: `prisma db push` reads
  * a generated column it does not know about as drift and drops it.
+ *
+ * @param table the table as SQL names it: `pages`, or `"WikiPage"` for a
+ *              PascalCase Prisma model, whose index is `"WikiPage_search_tsv_idx"`.
  */
 export function searchTsvDdl(table, { content = 'content', title = 'title' } = {}) {
     return {
@@ -83,7 +89,7 @@ export function searchTsvDdl(table, { content = 'content', title = 'title' } = {
             `ALTER TABLE ${table} DROP COLUMN IF EXISTS search_tsv`,
             `ALTER TABLE ${table} ADD COLUMN search_tsv tsvector GENERATED ALWAYS AS (${searchTsvSql(content, title)}) STORED`,
         ],
-        index: `CREATE INDEX IF NOT EXISTS ${table}_search_tsv_idx ON ${table} USING GIN (search_tsv)`,
+        index: `CREATE INDEX IF NOT EXISTS "${table.replaceAll('"', '')}_search_tsv_idx" ON ${table} USING GIN (search_tsv)`,
     };
 }
 /**

package/dist/stats-figures.js

@@ -5,10 +5,12 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // is not only visitors. Its own module because it holds state; `Stats` stays a
 // server component and hands it the digest, which is plain JSON.
 import { useMemo, useState } from 'react';
-import { TimeChart } from './chart.js';
+import { TimeChart, stepDecimals } from './chart.js';
 const count = (n) => n.toLocaleString('en');
-const duration = (s) => (s < 60 ? `${Math.round(s)}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`);
-const percent = (n) => `${Math.round(n)}%`;
+// Whole seconds and percentages, unless an axis tick's step needs more to tell it from the next.
+const places = (step) => (step ? stepDecimals(step) : 0);
+const duration = (s, step) => (s < 60 ? `${s.toFixed(places(step))}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`);
+const percent = (n, step) => `${n.toFixed(places(step))}%`;
 /**
  * The change from the window before: a share of the figure before, or for a
  * rate its difference in points, since a bounce rate up 10% of itself reads

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.56.0",
+  "version": "0.57.1",
   "description": "The portable half of a wiki: derived taxonomy and facet controls, a version-negotiating MCP transport, markdown twins, block rendering, a rich-text editor engine, conditional-GET plumbing, and the headers and CSP every origin sends.",
   "type": "module",
   "license": "MIT",