toiljs 0.0.83 → 0.0.85

package/build/devserver/analytics/index.js

@@ -1,46 +1,104 @@
+const FRAME_VERSION = 2;
+const METRIC_COUNTERS = 41;
+const MID = {
+    Requests: 0,
+    BytesOutL1: 1,
+    BytesInL1: 2,
+    Status2xx: 3,
+    Status4xx: 5,
+    StaticHits: 7,
+    WasmDispatches: 8,
+    GasUsed: 12,
+    DbOps: 13,
+    DbReads: 14,
+    DbWrites: 15,
+    StreamBytesIn: 25,
+    StreamBytesOut: 26,
+    MemGrownBytes: 39,
+};
 function devStats() {
+    const life = new Array(METRIC_COUNTERS).fill(0n);
+    life[MID.Requests] = 42n;
+    life[MID.BytesOutL1] = 12345n;
+    life[MID.BytesInL1] = 4096n;
+    life[MID.Status2xx] = 40n;
+    life[MID.Status4xx] = 2n;
+    life[MID.StaticHits] = 8n;
+    life[MID.WasmDispatches] = 34n;
+    life[MID.GasUsed] = 1000000n;
+    life[MID.DbOps] = 17n;
+    life[MID.DbReads] = 12n;
+    life[MID.DbWrites] = 5n;
+    life[MID.StreamBytesIn] = 2048n;
+    life[MID.StreamBytesOut] = 8192n;
+    life[MID.MemGrownBytes] = 262144n;
     return {
-        lifetime: [
-            ['requests', 42],
-            ['bytes_served', 12345],
-            ['status_2xx', 40],
-            ['status_3xx', 0],
-            ['status_4xx', 2],
-            ['status_5xx', 0],
-            ['static_hits', 8],
-            ['wasm_dispatches', 34],
-            ['db_ops', 17],
-            ['db_reads', 12],
-            ['db_writes', 5],
-            ['db_errors', 0],
-        ],
+        life,
+        connectedStreams: 3,
+        committedMemory: 65536,
         reqMinuteUsed: 5,
         reqMinuteCap: 100,
         reqDayUsed: 42,
         reqDayCap: 5000,
+        nowMs: 1_700_000_000_000,
     };
 }
 function encodeStats(s) {
-    const parts = [];
-    const head = Buffer.alloc(6);
-    head.writeUInt16LE(1, 0);
-    head.writeUInt32LE(s.lifetime.length, 2);
-    parts.push(head);
-    for (const [name, value] of s.lifetime) {
-        const nb = Buffer.from(name, 'utf8');
-        const nl = Buffer.alloc(4);
-        nl.writeUInt32LE(nb.length, 0);
-        const vb = Buffer.alloc(8);
-        vb.writeBigInt64LE(BigInt(value), 0);
-        parts.push(nl, nb, vb);
+    const head = Buffer.alloc(2 + 8 + 4);
+    head.writeUInt16LE(FRAME_VERSION, 0);
+    head.writeBigUInt64LE(BigInt(s.nowMs), 2);
+    head.writeUInt32LE(s.life.length, 10);
+    const body = Buffer.alloc(s.life.length * 8 + 48);
+    let o = 0;
+    for (const v of s.life) {
+        body.writeBigInt64LE(v, o);
+        o += 8;
     }
-    const tail = Buffer.alloc(32);
-    tail.writeBigInt64LE(BigInt(s.reqMinuteUsed), 0);
-    tail.writeBigUInt64LE(BigInt(s.reqMinuteCap), 8);
-    tail.writeBigInt64LE(BigInt(s.reqDayUsed), 16);
-    tail.writeBigUInt64LE(BigInt(s.reqDayCap), 24);
-    parts.push(tail);
-    return Buffer.concat(parts);
+    body.writeBigInt64LE(BigInt(s.connectedStreams), o);
+    o += 8;
+    body.writeBigInt64LE(BigInt(s.committedMemory), o);
+    o += 8;
+    body.writeBigInt64LE(BigInt(s.reqMinuteUsed), o);
+    o += 8;
+    body.writeBigUInt64LE(BigInt(s.reqMinuteCap), o);
+    o += 8;
+    body.writeBigInt64LE(BigInt(s.reqDayUsed), o);
+    o += 8;
+    body.writeBigUInt64LE(BigInt(s.reqDayCap), o);
+    return Buffer.concat([head, body]);
+}
+const MINUTE_RING_METRICS = new Set([0, 2, 1, 25, 26, 12, 13, 39, 41, 43]);
+function rangeShape(range, metricId) {
+    const isMinute = (range === 0 || range === 1) && MINUTE_RING_METRICS.has(metricId);
+    if (isMinute)
+        return range === 0 ? { count: 60, bucketSecs: 60 } : { count: 360, bucketSecs: 60 };
+    switch (range) {
+        case 0: return { count: 1, bucketSecs: 3600 };
+        case 1: return { count: 6, bucketSecs: 3600 };
+        case 2: return { count: 12, bucketSecs: 3600 };
+        case 3: return { count: 24, bucketSecs: 3600 };
+        case 4: return { count: 72, bucketSecs: 3600 };
+        case 5: return { count: 168, bucketSecs: 3600 };
+        case 6: return { count: 336, bucketSecs: 3600 };
+        case 7: return { count: 720, bucketSecs: 3600 };
+        default: return { count: 24, bucketSecs: 3600 };
+    }
+}
+function encodeSeries(metricId, range) {
+    const { count, bucketSecs } = rangeShape(range, metricId);
+    const nowMs = 1_700_000_000_000;
+    const head = Buffer.alloc(2 + 2 + 4 + 8 + 4);
+    head.writeUInt16LE(FRAME_VERSION, 0);
+    head.writeUInt16LE(metricId & 0xffff, 2);
+    head.writeUInt32LE(bucketSecs, 4);
+    head.writeBigUInt64LE(BigInt(nowMs), 8);
+    head.writeUInt32LE(count, 16);
+    const body = Buffer.alloc(count * 8);
+    for (let i = 0; i < count; i++) {
+        const v = BigInt(((i * 7 + metricId) % 50) + i);
+        body.writeBigInt64LE(v, i * 8);
+    }
+    return Buffer.concat([head, body]);
 }
 function encodeSiteList(names, hasMore) {
     const parts = [];
@@ -78,6 +136,24 @@ export function buildAnalyticsImports(ref, db) {
             db.lastResultVersion = -1;
             return frame.length;
         },
+        analytics_series: (domainPtr, domainLen, metricId, range) => {
+            if (domainLen > MAX_DOMAIN_LEN)
+                return ABSENT;
+            if (metricId < 0 || metricId > 44 || range < 0 || range > 7)
+                return ABSENT;
+            if (domainLen > 0) {
+                if (!ref.memory)
+                    throw new Error('analytics_series called before memory was bound');
+                const m = Buffer.from(ref.memory.buffer);
+                if (domainPtr < 0 || domainPtr + domainLen > m.length) {
+                    throw new Error('analytics_series: domain out of bounds');
+                }
+            }
+            const frame = encodeSeries(metricId, range);
+            db.lastResult = frame;
+            db.lastResultVersion = -1;
+            return frame.length;
+        },
         analytics_list_sites: (cursorPtr, cursorLen, limit) => {
             if (cursorLen > MAX_CURSOR_LEN)
                 return ABSENT;

package/build/devserver/runtime/module.js

@@ -37,6 +37,7 @@ const PROVIDED_IMPORTS = new Set([
     'env_get',
     'env_get_secure',
     'analytics_read',
+    'analytics_series',
     'analytics_list_sites',
     'crypto.fill_random',
     'crypto.random_uuid',
@@ -139,7 +140,7 @@ export class WasmServerModule {
         const rpcMethod = req.method.toUpperCase();
         const rpcMutating = rpcMethod === 'POST' || rpcMethod === 'PUT' || rpcMethod === 'PATCH' || rpcMethod === 'DELETE';
         if (rpcPath === '/__toil_rpc' && rpcMutating) {
-            const idHeader = req.headers.find(([n]) => n.toLowerCase() === 'toil-rpc')?.[1];
+            const idHeader = req.headers.find(([n]) => n.toLowerCase() === 'dacely-rpc')?.[1];
             const id = idHeader !== undefined && /^\d+$/.test(idHeader) ? Number(idHeader) : NaN;
             state.db.functionKind =
                 Number.isInteger(id) && id <= 0xffffffff

package/docs/caching.md

@@ -74,7 +74,7 @@ Because `@auth` guards and body-decode run before the cache directive is applied
 an unauthorized request is rejected with 401 before anything is cached, and a
 cached entry is only ever produced from a handler that actually ran.
 
-Caching is **always opt-in.** A response with no `Toil-Cache-Control` directive
+Caching is **always opt-in.** A response with no `Dacely-Cache-Control` directive
 (i.e. no `@cache` / `Response.cache(...)`) is never stored, there is no blind
 "cache every GET" mode, because an automatic window cannot tell a personalized
 response from a public one and would key it without a per-user component.
@@ -96,10 +96,10 @@ It has two tiers:
   offloaded to a sibling thread so they never stall the request path; a separate
   per-core disk budget caps total spilled bytes, with the same expiry + eviction.
   If spill is not enabled, a big response is simply not cached (reported as not
-  stored by the `Toil-Cache` tag).
+  stored by the `Dacely-Cache` tag).
 
 From a tenant's point of view nothing changes: you still just set a
-`Toil-Cache-Control` directive (via `@cache` / `Response.cache(...)`). The edge
+`Dacely-Cache-Control` directive (via `@cache` / `Response.cache(...)`). The edge
 decides RAM vs disk; both honor the same TTL and the same safety rails above.
 Expiry is enforced on read (a past-TTL entry is a miss) and reclaimed on the next
 insert that needs room. Nothing persists across a process restart.

package/examples/basic/client/routes/analytics.tsx

@@ -1,53 +1,181 @@
-// Demo of the per-domain Analytics API. `Server.REST.analytics.self()` is the real, typed
-// fetch client generated from the `@rest` controller in server/routes/Analytics.ts; the route
-// reads the toilscript `Analytics.self()` snapshot. Under `toiljs dev` the dev server returns
-// sample data; at the edge the same code reads the real metering.
-import { useState } from 'react';
+// Demo of the per-domain Analytics API + the historical time-series (graphs).
+//
+//   Server.REST.analytics.self()                                -> the current snapshot (typed getters)
+//   Server.REST.analytics.series({ query: { metric, range } })  -> a metric's history for a range
+//
+// Both are the real, typed fetch clients generated from the `@rest` controller in
+// server/routes/Analytics.ts, which reads the toilscript `Analytics.self()` / `Analytics.series()` API.
+// Under `toiljs dev` the dev server returns sample data; at the edge the SAME code reads the real
+// metering rings. The chart is a self-contained inline SVG (no chart library).
+import { useEffect, useState } from 'react';
 
-import { SiteAnalytics } from 'shared/server';
+import { SeriesData, SiteAnalytics } from 'shared/server';
 
 export const metadata: Toil.Metadata = {
     title: 'Analytics',
-    description: "This site's own analytics via the toilscript Analytics.self() API."
+    description: "This site's own analytics + historical graphs via the toilscript Analytics API."
 };
 
+// MetricId (mirrors the server enum). Only the graph-worthy ones are listed for the picker.
+const METRICS = [
+    { id: 0, label: 'Requests', unit: 'count' },
+    { id: 1, label: 'Bytes out (L1)', unit: 'bytes' },
+    { id: 2, label: 'Bytes in (L1)', unit: 'bytes' },
+    { id: 12, label: 'Gas used', unit: 'count' },
+    { id: 13, label: 'DB ops', unit: 'count' },
+    { id: 26, label: 'Stream bytes out', unit: 'bytes' },
+    { id: 39, label: 'Memory bandwidth', unit: 'bytes' },
+    { id: 41, label: 'Connected streams', unit: 'count' },
+    { id: 43, label: 'Committed memory', unit: 'bytes' }
+] as const;
+
+// AnalyticsRange (mirrors the server enum).
+const RANGES = [
+    { id: 0, label: '1h' },
+    { id: 1, label: '6h' },
+    { id: 3, label: '24h' },
+    { id: 5, label: '7d' },
+    { id: 7, label: '30d' }
+] as const;
+
+type Unit = 'count' | 'bytes';
+
+function fmt(n: number, unit: Unit): string {
+    if (unit === 'bytes') {
+        const u = ['B', 'KB', 'MB', 'GB'];
+        let i = 0;
+        while (n >= 1024 && i < u.length - 1) {
+            n /= 1024;
+            i++;
+        }
+        return `${n.toFixed(i === 0 ? 0 : 1)} ${u[i]}`;
+    }
+    return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(Math.round(n));
+}
+
+/** A dependency-free SVG line chart of the per-second rate (value / bucketSecs). */
+function LineChart({ points, bucketSecs, unit }: { points: number[]; bucketSecs: number; unit: Unit }) {
+    const W = 640;
+    const H = 220;
+    const pad = 40;
+    const rate = points.map((v) => (bucketSecs > 0 ? v / bucketSecs : 0));
+    const max = Math.max(1, ...rate);
+    const n = rate.length;
+    const x = (i: number) => pad + (n <= 1 ? 0 : (i / (n - 1)) * (W - 2 * pad));
+    const y = (v: number) => H - pad - (v / max) * (H - 2 * pad);
+    const line = rate.map((v, i) => `${i === 0 ? 'M' : 'L'}${x(i).toFixed(1)},${y(v).toFixed(1)}`).join(' ');
+    const area = `${line} L${x(n - 1).toFixed(1)},${H - pad} L${x(0).toFixed(1)},${H - pad} Z`;
+
+    return (
+        <svg
+            viewBox={`0 0 ${W} ${H}`}
+            width="100%"
+            role="img"
+            aria-label="time series chart"
+            style={{ maxWidth: W, background: '#0b0f19', borderRadius: 8 }}>
+            <line x1={pad} y1={H - pad} x2={W - pad} y2={H - pad} stroke="#33415580" />
+            <line x1={pad} y1={pad} x2={pad} y2={H - pad} stroke="#33415580" />
+            <text x={6} y={pad + 4} fill="#94a3b8" fontSize={11}>
+                {fmt(max, unit)}/s
+            </text>
+            <text x={6} y={H - pad} fill="#94a3b8" fontSize={11}>
+                0
+            </text>
+            {n > 0 && <path d={area} fill="#38bdf822" />}
+            {n > 1 && <path d={line} fill="none" stroke="#38bdf8" strokeWidth={2} />}
+            {n === 1 && <circle cx={x(0)} cy={y(rate[0])} r={3} fill="#38bdf8" />}
+        </svg>
+    );
+}
+
 export default function AnalyticsDemo() {
     const [stats, setStats] = useState<SiteAnalytics | null>(null);
+    const [series, setSeries] = useState<SeriesData | null>(null);
+    const [metric, setMetric] = useState(0);
+    const [range, setRange] = useState(3);
     const [err, setErr] = useState('');
 
-    const load = async () => {
+    const loadStats = async () => {
         try {
-            setStats(await Server.REST.analytics.self());
+            setStats(await Server.REST.analyticsRoutes.self());
             setErr('');
         } catch (e) {
             setErr(parseError(e));
         }
     };
 
+    // Refetch the graph whenever the metric or range changes.
+    useEffect(() => {
+        Server.REST.analyticsRoutes
+            .series({ query: { metric, range } })
+            .then(setSeries)
+            .catch((e: unknown) => setErr(parseError(e)));
+    }, [metric, range]);
+
     const cap = (used: bigint, max: bigint) => `${used} / ${max ? String(max) : '∞'}`;
+    const meta = METRICS.find((m) => m.id === metric) ?? METRICS[0];
+    const points = series ? series.points.map(Number) : [];
 
     return (
         <main>
             <h1>Analytics</h1>
             <p>
-                <code>Server.REST.analytics.self()</code> reads this site's own analytics via the toilscript{' '}
-                <code>Analytics.self()</code> API (the per-domain metering counters + plan limits). Under{' '}
-                <code>toiljs dev</code> you get sample data; at the edge it is the real metering, with the same code.
+                <code>analytics.self()</code> reads this site's snapshot; <code>analytics.series(metric, range)</code>{' '}
+                reads the historical rings (30-day retention). Under <code>toiljs dev</code> you get sample data; at
+                the edge it is the real metering, same code.
             </p>
-            <button onClick={load}>Load my site analytics</button>
-            {err && <p>{err}</p>}
-            {stats && (
-                <ul>
-                    <li>requests: {String(stats.requests)}</li>
-                    <li>bytes served: {String(stats.bytesServed)}</li>
-                    <li>2xx responses: {String(stats.status2xx)}</li>
-                    <li>wasm dispatches: {String(stats.wasmDispatches)}</li>
-                    <li>db ops: {String(stats.dbOps)}</li>
-                    <li>requests this minute: {cap(stats.reqMinuteUsed, stats.reqMinuteCap)}</li>
-                    <li>requests today: {cap(stats.reqDayUsed, stats.reqDayCap)}</li>
-                </ul>
-            )}
-            <p>
+
+            <section>
+                <h2>History</h2>
+                <div style={{ display: 'flex', gap: 12, alignItems: 'center', flexWrap: 'wrap', marginBottom: 8 }}>
+                    <label>
+                        Metric{' '}
+                        <select value={metric} onChange={(e) => setMetric(Number(e.currentTarget.value))}>
+                            {METRICS.map((m) => (
+                                <option key={m.id} value={m.id}>
+                                    {m.label}
+                                </option>
+                            ))}
+                        </select>
+                    </label>
+                    <label>
+                        Range{' '}
+                        <select value={range} onChange={(e) => setRange(Number(e.currentTarget.value))}>
+                            {RANGES.map((r) => (
+                                <option key={r.id} value={r.id}>
+                                    {r.label}
+                                </option>
+                            ))}
+                        </select>
+                    </label>
+                    <span style={{ color: '#64748b' }}>
+                        {series ? `${series.points.length} buckets · ${series.bucketSecs}s each` : ''}
+                    </span>
+                </div>
+                <LineChart points={points} bucketSecs={series?.bucketSecs ?? 3600} unit={meta.unit} />
+            </section>
+
+            <section style={{ marginTop: 24 }}>
+                <h2>Snapshot</h2>
+                <button onClick={loadStats}>Load my site analytics</button>
+                {err && <p style={{ color: '#f87171' }}>{err}</p>}
+                {stats && (
+                    <ul>
+                        <li>requests: {String(stats.requests)}</li>
+                        <li>bytes out (L1): {String(stats.bytesOutL1)}</li>
+                        <li>bytes in (L1): {String(stats.bytesInL1)}</li>
+                        <li>gas used: {String(stats.gasUsed)}</li>
+                        <li>2xx responses: {String(stats.status2xx)}</li>
+                        <li>db ops: {String(stats.dbOps)}</li>
+                        <li>connected streams (live): {String(stats.connectedStreams)}</li>
+                        <li>committed memory (live): {fmt(Number(stats.committedMemory), 'bytes')}</li>
+                        <li>requests this minute: {cap(stats.reqMinuteUsed, stats.reqMinuteCap)}</li>
+                        <li>requests today: {cap(stats.reqDayUsed, stats.reqDayCap)}</li>
+                    </ul>
+                )}
+            </section>
+
+            <p style={{ marginTop: 24 }}>
                 <Toil.Link href="/">Back home</Toil.Link>
             </p>
         </main>

package/examples/basic/server/models/SiteAnalytics.ts

@@ -3,12 +3,27 @@
 @data
 export class SiteAnalytics {
     requests: i64 = 0;
-    bytesServed: i64 = 0;
+    bytesOutL1: i64 = 0;
+    bytesInL1: i64 = 0;
     status2xx: i64 = 0;
     wasmDispatches: i64 = 0;
     dbOps: i64 = 0;
+    gasUsed: i64 = 0;
+    connectedStreams: i64 = 0;
+    committedMemory: i64 = 0;
     reqMinuteUsed: i64 = 0;
     reqMinuteCap: i64 = 0;
     reqDayUsed: i64 = 0;
     reqDayCap: i64 = 0;
 }
+
+/** One metric's historical time-series for a range, from `Analytics.series(metric, range)`: the raw
+ *  per-bucket totals (oldest→newest) plus the bucket width + newest-bucket end, so the client can draw a
+ *  graph and derive per-second rates. Demonstrates the typed series API. */
+@data
+export class SeriesData {
+    metric: i32 = 0;
+    bucketSecs: u32 = 0;
+    headMs: u64 = 0;
+    points: i64[] = [];
+}

package/examples/basic/server/routes/Analytics.ts

@@ -1,4 +1,6 @@
-import { SiteAnalytics } from '../models/SiteAnalytics';
+import { RouteContext } from 'toiljs/server/runtime';
+
+import { SeriesData, SiteAnalytics } from '../models/SiteAnalytics';
 
 /**
  * This site's own analytics, mounted at `/analytics`. On the client:
@@ -16,15 +18,38 @@ class AnalyticsRoutes {
     public self(): SiteAnalytics {
         const s = Analytics.self();
         const r = new SiteAnalytics();
-        r.requests = s.lifetime.has('requests') ? s.lifetime.get('requests') : 0;
-        r.bytesServed = s.lifetime.has('bytes_served') ? s.lifetime.get('bytes_served') : 0;
-        r.status2xx = s.lifetime.has('status_2xx') ? s.lifetime.get('status_2xx') : 0;
-        r.wasmDispatches = s.lifetime.has('wasm_dispatches') ? s.lifetime.get('wasm_dispatches') : 0;
-        r.dbOps = s.lifetime.has('db_ops') ? s.lifetime.get('db_ops') : 0;
+        // Typed getters: no magic strings, no `.has()/.get()` map dance.
+        r.requests = s.requests;
+        r.bytesOutL1 = s.bytesOutL1;
+        r.bytesInL1 = s.bytesInL1;
+        r.status2xx = s.status2xx;
+        r.wasmDispatches = s.wasmDispatches;
+        r.dbOps = s.dbOps;
+        r.gasUsed = s.gasUsed;
+        r.connectedStreams = s.connectedStreams;
+        r.committedMemory = s.committedMemory;
         r.reqMinuteUsed = s.reqMinuteUsed;
         r.reqMinuteCap = <i64>s.reqMinuteCap;
         r.reqDayUsed = s.reqDayUsed;
         r.reqDayCap = <i64>s.reqDayCap;
         return r;
     }
+
+    /// Any metric's historical time-series for a range, for graphs:
+    ///   `await Server.REST.analytics.series({ query: { metric: MetricId, range: AnalyticsRange } })`
+    /// `metric` is a `MetricId` (0..44), `range` an `AnalyticsRange` (0=1h .. 7=30d, default 24h). Returns
+    /// the per-bucket totals oldest→newest; the client derives rates (value / bucketSecs) and draws them.
+    @get('/series')
+    public series(ctx: RouteContext): SeriesData {
+        const metric = <MetricId>i32.parse(ctx.query('metric'));
+        const rangeStr = ctx.query('range');
+        const range = rangeStr.length > 0 ? <AnalyticsRange>i32.parse(rangeStr) : AnalyticsRange.H24;
+        const s = Analytics.series(metric, range);
+        const out = new SeriesData();
+        out.metric = s.metric;
+        out.bucketSecs = s.bucketSecs;
+        out.headMs = s.headMs;
+        out.points = s.points;
+        return out;
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "toiljs",
     "type": "module",
-    "version": "0.0.83",
+    "version": "0.0.85",
     "author": "Dacely",
     "description": "The modern React framework: a file-based React frontend and a ToilScript-compiled WebAssembly backend.",
     "repository": {

package/server/runtime/exports/index.ts

@@ -61,7 +61,7 @@ export function handle(req_ofs: i32, req_len: i32): i64 {
         // Run the handler lifecycle hooks around BOTH the RPC and the normal path, so an app that does
         // central bookkeeping/auth in onRequestStarted is not silently bypassed for /__toil_rpc.
         handler.onRequestStarted(req);
-        // Reserved RPC endpoint: a `POST /__toil_rpc` carrying a `toil-rpc` method id dispatches to the
+        // Reserved RPC endpoint: a `POST /__toil_rpc` carrying a `dacely-rpc` method id dispatches to the
         // registered @service/@remote method (which applies its own @auth/@ratelimit guards); any other
         // request returns null here and falls through to the normal handler.
         const rpcHit = Rpc.dispatch(req);

package/server/runtime/response.ts

@@ -178,7 +178,7 @@ export class Response {
             v += 'auth=1';
         }
         if (v.length > 0) {
-            this.setHeader('toil-cache-control', v);
+            this.setHeader('dacely-cache-control', v);
         }
 
         return this;

package/server/runtime/rpc/Rpc.ts

@@ -3,7 +3,7 @@
  * function self-registers here at module init (compiler-injected), keyed by a
  * deterministic method id (FNV-1a of `"Service.method"` / `"fnName"` — the same
  * hash the generated client sends). The wasm `handle` export dispatches a
- * reserved `POST /__toil_rpc` (method id in the `toil-rpc` header, `@data`-encoded
+ * reserved `POST /__toil_rpc` (method id in the `dacely-rpc` header, `@data`-encoded
  * args in the body) to the matching method and returns its `@data`-encoded
  * result. Mirrors `Rest` (../rest/Rest.ts); calls are STATELESS — a fresh service
  * instance per call, exactly like a `@rest` controller.
@@ -15,7 +15,7 @@ import { Response } from '../response';
 /** The reserved path a generated RPC client POSTs to. */
 export const RPC_PATH: string = '/__toil_rpc';
 /** The request header carrying the decimal `u32` method id. */
-export const RPC_HEADER: string = 'toil-rpc';
+export const RPC_HEADER: string = 'dacely-rpc';
 
 /** A registered RPC method: takes the encoded-args body and returns a `Response` - the encoded result
  *  (`Response.bytes`) on success, or a guard's `401`/`429` when the method carries `@auth`/`@ratelimit`.

package/src/compiler/sri.ts

@@ -46,33 +46,84 @@ function toLocalAsset(url: string, base: string): string | null {
 export function injectSri(html: string, outDir: string, base: string): string {
     const cache = new Map<string, string | null>();
     return html.replace(/<(script|link)\b([^>]*)>/gi, (full, tag: string, rawAttrs: string) => {
-        if (/\bintegrity\s*=/i.test(rawAttrs)) return full; // already integrity-tagged
+        // `(?<![\w-])` (not `\b`) so a hyphenated decoy attr never counts as the real one: `\bintegrity`
+        // matches inside `data-integrity` (would wrongly skip us), `\bsrc` inside `data-src` (would hash
+        // the wrong URL). The guard requires the attr name to start at a real attribute boundary.
+        if (/(?<![\w-])integrity\s*=/i.test(rawAttrs)) return full; // already integrity-tagged
         const selfClose = /\/\s*$/.test(rawAttrs);
         const attrs = rawAttrs.replace(/\s*\/\s*$/, '');
         const isScript = tag.toLowerCase() === 'script';
         if (!isScript) {
-            const rel = /\brel\s*=\s*["']?([^"'\s>]+)/i.exec(attrs)?.[1]?.toLowerCase();
+            const rel = /(?<![\w-])rel\s*=\s*["']?([^"'\s>]+)/i.exec(attrs)?.[1]?.toLowerCase();
             if (rel !== 'stylesheet' && rel !== 'modulepreload') return full;
         }
         const attr = isScript ? 'src' : 'href';
-        const url = new RegExp(`\\b${attr}\\s*=\\s*["']([^"']+)["']`, 'i').exec(attrs)?.[1];
+        const url = new RegExp(`(?<![\\w-])${attr}\\s*=\\s*["']([^"']+)["']`, 'i').exec(attrs)?.[1];
         if (url === undefined) return full; // inline script or no url
         const rel = toLocalAsset(url, base);
         if (rel === null) return full;
         const sri = computeSri(path.join(outDir, rel), cache);
         if (sri === null) return full;
-        const cross = /\bcrossorigin\b/i.test(attrs) ? '' : ' crossorigin="anonymous"';
+        const cross = /(?<![\w-])crossorigin(?![\w-])/i.test(attrs) ? '' : ' crossorigin="anonymous"';
         return `<${tag}${attrs} integrity="${sri}"${cross}${selfClose ? ' /' : ''}>`;
     });
 }
 
+/**
+ * Build an `<script type="importmap">` tag whose `integrity` section maps every emitted JS chunk
+ * (`assets/*.js`) to its sha384. Tag-level SRI only protects the ENTRY script: the rest of the
+ * module graph -- static imports (the react vendor chunk) and lazily `import()`ed route chunks --
+ * is fetched by the module loader, which does NOT inherit the tag's integrity. The import map's
+ * `integrity` field is the platform mechanism that extends verification to those fetches; browsers
+ * without support ignore the key (progressive enhancement, nothing breaks). Returns `null` when
+ * there are no chunks.
+ */
+export function buildImportMapIntegrity(
+    outDir: string,
+    base: string,
+    cache: Map<string, string | null> = new Map(),
+): string | null {
+    const assetsDir = path.join(outDir, 'assets');
+    let names: string[];
+    try {
+        names = fs.readdirSync(assetsDir).filter((n) => n.endsWith('.js'));
+    } catch {
+        return null;
+    }
+    const prefix = base.endsWith('/') ? base : `${base}/`;
+    const integrity: Record<string, string> = {};
+    for (const name of names.sort()) {
+        const sri = computeSri(path.join(assetsDir, name), cache);
+        if (sri !== null) integrity[`${prefix}assets/${name}`] = sri;
+    }
+    if (Object.keys(integrity).length === 0) return null;
+    return `<script type="importmap">${JSON.stringify({ integrity })}</script>`;
+}
+
+/** Insert the import-map tag where it takes effect: right after `<head>` (an import map must be
+ *  parsed before any module load). Falls back to prepending before the first `<script`. No-op if
+ *  an integrity import map is already present (idempotent on an already-processed shell). */
+export function injectImportMap(html: string, importMapTag: string): string {
+    if (html.includes('<script type="importmap">{"integrity"')) return html;
+    const head = /<head[^>]*>/i.exec(html);
+    if (head !== null) {
+        const at = head.index + head[0].length;
+        return `${html.slice(0, at)}\n    ${importMapTag}${html.slice(at)}`;
+    }
+    const script = html.indexOf('<script');
+    if (script !== -1) return `${html.slice(0, script)}${importMapTag}\n${html.slice(script)}`;
+    return html;
+}
+
 /**
  * Build-only plugin: after the bundle is written, rewrites the built shell (`outDir/index.html`) so
- * every local script/stylesheet/modulepreload carries an `integrity`. It runs in `closeBundle`
- * (assets are on disk, so real bytes are hashed) and is registered BEFORE the prerender / SSR-
- * template passes, which bake per-route HTML, bracket templates, and the SSR `.tmpl` FROM this
- * shell -- so every emitted page inherits SRI and the `.tmpl` coherence hash covers it. Build-only:
- * the dev server serves un-hashed modules straight from Vite, where SRI would be meaningless.
+ * (a) every local script/stylesheet/modulepreload TAG carries an `integrity`, and (b) an import map
+ * `integrity` section covers every emitted JS chunk, so the FULL module graph -- the entry's static
+ * imports and every dynamically `import()`ed route chunk -- is verified, not just the entry tag. It
+ * runs in `closeBundle` (assets are on disk, so real bytes are hashed) and is registered BEFORE the
+ * prerender / SSR-template passes, which bake per-route HTML, bracket templates, and the SSR `.tmpl`
+ * FROM this shell -- so every emitted page inherits both and the `.tmpl` coherence hash covers them.
+ * Build-only: the dev server serves un-hashed modules straight from Vite, where SRI is meaningless.
  */
 export function sriPlugin(cfg: ResolvedToilConfig): Plugin {
     return {
@@ -83,7 +134,10 @@ export function sriPlugin(cfg: ResolvedToilConfig): Plugin {
             const shell = path.join(outDir, 'index.html');
             if (!fs.existsSync(shell)) return;
             const html = fs.readFileSync(shell, 'utf8');
-            const out = injectSri(html, outDir, cfg.base);
+            const cache = new Map<string, string | null>();
+            let out = injectSri(html, outDir, cfg.base);
+            const importMap = buildImportMapIntegrity(outDir, cfg.base, cache);
+            if (importMap !== null) out = injectImportMap(out, importMap);
             if (out !== html) fs.writeFileSync(shell, out);
         },
     };