toiljs 0.0.58 → 0.0.60

package/build/devserver/db/types.d.ts

@@ -0,0 +1,58 @@
+export interface DbDevState {
+    handles: string[];
+    lastResult: Buffer | null;
+    lastResultVersion: number;
+}
+export declare function freshDbState(): DbDevState;
+export interface Reservation {
+    amount: bigint;
+    expiresMs: number;
+    confirmed: boolean;
+}
+export interface CapLedger {
+    total: bigint;
+    reservations: Map<bigint, Reservation>;
+    nextId: bigint;
+}
+export interface DbSnapshot {
+    store: Record<string, {
+        v: string;
+        sv: number;
+    }>;
+    views: Record<string, {
+        v: string;
+        sv: number;
+    }>;
+    members: Record<string, Record<string, {
+        v: string;
+        sv: number;
+    }>>;
+    counters: Record<string, string>;
+    events: Record<string, {
+        v: string;
+        sv: number;
+    }[]>;
+    eventDedup: Record<string, string[]>;
+    capacity: Record<string, {
+        total: string;
+        nextId: string;
+        reservations: [string, {
+            amount: string;
+            expiresMs: number;
+            confirmed: boolean;
+        }][];
+    }>;
+}
+export declare const MAX_RESERVATIONS = 4096;
+export declare const MAX_RESERVATION_TTL_MS = 86400000;
+export declare const MAX_NAME = 512;
+export declare const MAX_KEY = 4096;
+export declare const MAX_VALUE: number;
+export declare function satI64(v: bigint): bigint;
+export declare const ABSENT = -2;
+export declare const TOO_SMALL = -1;
+export declare const INVALID_HANDLE = -1001;
+export declare const ALREADY_EXISTS = -1003;
+export declare const CONFLICT = -1004;
+export declare const CODEC_ERR = -1006;
+export declare const TOO_MANY_KEYS = -1020;

package/build/devserver/db/types.js

@@ -0,0 +1,20 @@
+export function freshDbState() {
+    return { handles: [], lastResult: null, lastResultVersion: -1 };
+}
+export const MAX_RESERVATIONS = 4096;
+export const MAX_RESERVATION_TTL_MS = 86_400_000;
+export const MAX_NAME = 512;
+export const MAX_KEY = 4096;
+export const MAX_VALUE = 256 * 1024;
+const I64_MIN = -(2n ** 63n);
+const I64_MAX = 2n ** 63n - 1n;
+export function satI64(v) {
+    return v < I64_MIN ? I64_MIN : v > I64_MAX ? I64_MAX : v;
+}
+export const ABSENT = -2;
+export const TOO_SMALL = -1;
+export const INVALID_HANDLE = -1001;
+export const ALREADY_EXISTS = -1003;
+export const CONFLICT = -1004;
+export const CODEC_ERR = -1006;
+export const TOO_MANY_KEYS = -1020;

package/build/devserver/email/index.js

@@ -1,4 +1,4 @@
-import { loadEnvFiles } from '../dotenv.js';
+import { loadEnvFiles } from '../config/dotenv.js';
 import { EmailCaps } from './caps.js';
 import { resolveEmailConfig } from './config.js';
 import { sendVia } from './providers.js';

package/build/devserver/index.d.ts

@@ -1,24 +1,9 @@
-import type { EmailBackendConfig } from 'toiljs/shared';
-import { type ViteTarget } from './proxy.js';
-export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './envelope.js';
-export type { EnvelopeRequest, EnvelopeResponse } from './envelope.js';
-export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './module.js';
-export type { WasmDispatchResult } from './module.js';
-export { buildHostImports, freshDispatchState } from './host.js';
-export type { DispatchState, MemoryRef } from './host.js';
-export type { ViteTarget } from './proxy.js';
-export interface DevServerOptions {
-    readonly root: string;
-    readonly port: number;
-    readonly host?: string;
-    readonly wasmFile: string;
-    readonly vite: ViteTarget;
-    readonly maxBodyLength?: number;
-    readonly email?: EmailBackendConfig;
-}
-export interface RunningDevServer {
-    readonly port: number;
-    readonly host: string;
-    close(): Promise<void>;
-}
-export declare function startDevServer(options: DevServerOptions): Promise<RunningDevServer>;
+export { startDevServer } from './server.js';
+export type { DevServerOptions, RunningDevServer } from './server.js';
+export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './http/envelope.js';
+export type { EnvelopeRequest, EnvelopeResponse } from './http/envelope.js';
+export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './runtime/module.js';
+export type { WasmDispatchResult } from './runtime/module.js';
+export { buildHostImports, freshDispatchState } from './runtime/host.js';
+export type { DispatchState, MemoryRef } from './runtime/host.js';
+export type { ViteTarget } from './http/proxy.js';

package/build/devserver/index.js

@@ -1,165 +1,4 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { Server } from '@dacely/hyper-express';
-import pc from 'picocolors';
-import { applyCacheRule, lookupCache } from './cache.js';
-import { initEmailService } from './email/index.js';
-import { METHOD_CODES } from './envelope.js';
-import { WasmServerModule } from './module.js';
-import { proxyToVite, wireWebsocketProxy } from './proxy.js';
-export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './envelope.js';
-export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './module.js';
-export { buildHostImports, freshDispatchState } from './host.js';
-const DEFAULT_MAX_BODY_LENGTH = 1024 * 1024 * 8;
-const VITE_PREFIXES = ['/@', '/node_modules/', '/__toil/'];
-const MIME = {
-    '.html': 'text/html; charset=utf-8',
-    '.js': 'text/javascript; charset=utf-8',
-    '.mjs': 'text/javascript; charset=utf-8',
-    '.css': 'text/css; charset=utf-8',
-    '.json': 'application/json; charset=utf-8',
-    '.txt': 'text/plain; charset=utf-8',
-    '.svg': 'image/svg+xml',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.avif': 'image/avif',
-    '.gif': 'image/gif',
-    '.ico': 'image/x-icon',
-    '.wasm': 'application/wasm',
-    '.woff2': 'font/woff2',
-};
-function isViteInternal(url) {
-    return VITE_PREFIXES.some((p) => url.startsWith(p));
-}
-function resolveSendfile(root, file) {
-    const resolved = path.resolve(root, file);
-    if (resolved !== root && !resolved.startsWith(root + path.sep))
-        return null;
-    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile())
-        return null;
-    return resolved;
-}
-async function toEnvelopeRequest(request) {
-    const hasBody = request.method !== 'GET' && request.method !== 'HEAD';
-    const body = hasBody ? new Uint8Array(await request.buffer()) : new Uint8Array(0);
-    const xff = request.headers['x-forwarded-for'];
-    const clientIp = typeof xff === 'string' && xff.length > 0 ? xff.split(',')[0].trim() : '127.0.0.1';
-    return {
-        method: request.method,
-        path: request.url,
-        headers: Object.entries(request.headers),
-        body,
-        clientIp,
-    };
-}
-function sendWasmResponse(response, root, result) {
-    response.status(result.status);
-    let hasContentType = false;
-    for (const [name, value] of result.headers) {
-        if (name.toLowerCase() === 'content-type')
-            hasContentType = true;
-        response.header(name, value);
-    }
-    response.header('server', 'toil-dev');
-    if (result.sendfile !== null) {
-        const file = resolveSendfile(root, result.sendfile);
-        if (file === null) {
-            response.status(404).send('not found\n');
-            return;
-        }
-        if (!hasContentType) {
-            response.header('content-type', MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream');
-        }
-        response.sendFile(file);
-        return;
-    }
-    if (!hasContentType)
-        response.header('content-type', 'text/plain; charset=utf-8');
-    response.send(Buffer.from(result.body.buffer, result.body.byteOffset, result.body.length));
-}
-export async function startDevServer(options) {
-    const host = options.host ?? '127.0.0.1';
-    const root = path.resolve(options.root);
-    const emailInit = initEmailService(root, options.email);
-    if (emailInit.service !== null) {
-        process.stdout.write(pc.dim(`  ✉ email enabled: ${emailInit.note}`) + '\n');
-    }
-    else if (emailInit.note !== null) {
-        process.stdout.write(pc.yellow('  ! ') + pc.dim(`email off: ${emailInit.note}`) + '\n');
-    }
-    const module = new WasmServerModule(options.wasmFile);
-    let warnedMissing = false;
-    let loadedOnce = false;
-    const refresh = () => {
-        try {
-            if (module.refresh() && loadedOnce) {
-                process.stdout.write(pc.green('  ✓ ') + pc.dim('server module reloaded') + '\n');
-            }
-            loadedOnce ||= module.available;
-        }
-        catch (e) {
-            process.stdout.write(pc.red(`  ✗ server wasm failed to load: ${String(e)}`) + '\n');
-        }
-        if (!module.available && !warnedMissing) {
-            warnedMissing = true;
-            process.stdout.write(pc.yellow('  ! ') +
-                pc.dim(`server wasm not found at ${options.wasmFile}; serving client only`) +
-                '\n');
-        }
-    };
-    refresh();
-    const app = new Server({
-        max_body_length: options.maxBodyLength ?? DEFAULT_MAX_BODY_LENGTH,
-        max_body_buffer: 1024 * 32,
-        fast_abort: true,
-    });
-    app.set_error_handler((_request, response, error) => {
-        if (response.completed)
-            return;
-        response.atomic(() => {
-            response.status(500).send(`internal error: ${error.message}\n`);
-        });
-    });
-    wireWebsocketProxy(app, options.vite);
-    app.any('/*', async (request, response) => {
-        response.removeHeader('uWebSockets');
-        const dispatchable = !isViteInternal(request.url) && METHOD_CODES[request.method] !== undefined;
-        if (dispatchable)
-            refresh();
-        if (dispatchable && module.available) {
-            const envelopeReq = await toEnvelopeRequest(request);
-            const cacheHost = request.headers.host ?? 'dev';
-            const hasAuth = request.headers.cookie !== undefined || request.headers.authorization !== undefined;
-            const cached = lookupCache(cacheHost, request.method, request.url, envelopeReq.body);
-            if (cached !== null) {
-                sendWasmResponse(response, root, cached);
-                return;
-            }
-            try {
-                const result = module.dispatch(envelopeReq);
-                if (!result.unhandled) {
-                    const finalized = applyCacheRule(cacheHost, request.method, request.url, envelopeReq.body, hasAuth, result);
-                    sendWasmResponse(response, root, finalized);
-                    return;
-                }
-            }
-            catch (e) {
-                process.stdout.write(pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) +
-                    '\n');
-                response.status(500).send('internal error\n');
-                return;
-            }
-        }
-        await proxyToVite(request, response, options.vite);
-    });
-    await app.listen(options.port, host);
-    return {
-        port: options.port,
-        host,
-        close: async () => {
-            await app.shutdown();
-        },
-    };
-}
+export { startDevServer } from './server.js';
+export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './http/envelope.js';
+export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './runtime/module.js';
+export { buildHostImports, freshDispatchState } from './runtime/host.js';

package/build/devserver/{host.d.ts → runtime/host.d.ts}

@@ -1,5 +1,5 @@
+import { type DbDevState } from '../db/index.js';
 import { type CryptoState } from './crypto.js';
-import { type DbDevState } from './database.js';
 export declare class WasmAbortError extends Error {
     constructor(message: string, fileName: string, line: number, column: number);
 }

package/build/devserver/{host.js → runtime/host.js}

@@ -1,9 +1,9 @@
+import { devEnvGet, devEnvGetSecure } from '../config/env.js';
+import { ratelimitCheck } from '../config/ratelimit.js';
+import { buildDatabaseImports, freshDbState } from '../db/index.js';
+import { EmailStatus, getEmailService } from '../email/index.js';
+import { parseEmailBlob } from '../email/wire.js';
 import { buildCryptoImports, freshCryptoState } from './crypto.js';
-import { buildDatabaseImports, freshDbState } from './database.js';
-import { EmailStatus, getEmailService } from './email/index.js';
-import { parseEmailBlob } from './email/wire.js';
-import { devEnvGet, devEnvGetSecure } from './env.js';
-import { ratelimitCheck } from './ratelimit.js';
 const MAX_TOTAL_HEADERS_BYTES = 64 * 1024;
 const MAX_HEADER_NAME_LEN = 256;
 const MAX_HEADER_VALUE_LEN = 8192;
@@ -157,7 +157,7 @@ export function buildHostImports(ref, state) {
             env_get: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, false),
             env_get_secure: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, true),
             thread_spawn: (_startArg) => -1,
-            'Date.now': () => Date.now(),
+            'Date.now': () => BigInt(Date.now()),
             ...buildCryptoImports(ref, state.crypto),
             ...buildDatabaseImports(ref, state.db),
         },

package/build/devserver/{module.d.ts → runtime/module.d.ts}

@@ -1,4 +1,4 @@
-import { type EnvelopeRequest } from './envelope.js';
+import { type EnvelopeRequest } from '../http/envelope.js';
 export { WasmAbortError } from './host.js';
 export declare const UNHANDLED_HEADER = "x-toil-unhandled";
 export interface WasmDispatchResult {

package/build/devserver/{module.js → runtime/module.js}

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
-import { decodeResponseEnvelope, encodeRequestEnvelope, unpackHandleResult, } from './envelope.js';
+import { persistDb, setDbCatalog } from '../db/index.js';
+import { decodeResponseEnvelope, encodeRequestEnvelope, unpackHandleResult, } from '../http/envelope.js';
 import { buildHostImports, freshDispatchState } from './host.js';
 export { WasmAbortError } from './host.js';
 export const UNHANDLED_HEADER = 'x-toil-unhandled';
@@ -50,6 +51,8 @@ const PROVIDED_IMPORTS = new Set([
     'data.counter_get',
     'data.counter_add',
     'data.append',
+    'data.append_once',
+    'data.enqueue',
     'data.latest',
     'data.capacity_set_total',
     'data.capacity_available',
@@ -57,6 +60,8 @@ const PROVIDED_IMPORTS = new Set([
     'data.capacity_confirm',
     'data.capacity_cancel',
     'data.take_result',
+    'data.result_schema_version',
+    'data.write_allowed',
 ]);
 export class WasmServerModule {
     wasmPath;
@@ -84,6 +89,7 @@ export class WasmServerModule {
         const module = new WebAssembly.Module(bytes);
         this.assertImportSurface(module);
         this.assertExportSurface(module);
+        setDbCatalog(bytes);
         this.module = module;
         this.loadedMtimeMs = mtimeMs;
         return true;
@@ -110,6 +116,7 @@ export class WasmServerModule {
         const headers = [...resp.headers, ...state.headers];
         const status = state.status ?? resp.status;
         const unhandled = headers.some(([n]) => n.toLowerCase() === UNHANDLED_HEADER);
+        persistDb();
         return {
             status,
             headers: headers.filter(([n]) => n.toLowerCase() !== UNHANDLED_HEADER),

package/build/devserver/server.d.ts

@@ -0,0 +1,17 @@
+import type { EmailBackendConfig } from 'toiljs/shared';
+import { type ViteTarget } from './http/proxy.js';
+export interface DevServerOptions {
+    readonly root: string;
+    readonly port: number;
+    readonly host?: string;
+    readonly wasmFile: string;
+    readonly vite: ViteTarget;
+    readonly maxBodyLength?: number;
+    readonly email?: EmailBackendConfig;
+}
+export interface RunningDevServer {
+    readonly port: number;
+    readonly host: string;
+    close(): Promise<void>;
+}
+export declare function startDevServer(options: DevServerOptions): Promise<RunningDevServer>;

package/build/devserver/server.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Server } from '@dacely/hyper-express';
+import pc from 'picocolors';
+import { configureDbPersistence } from './db/index.js';
+import { initEmailService } from './email/index.js';
+import { applyCacheRule, lookupCache } from './http/cache.js';
+import { METHOD_CODES } from './http/envelope.js';
+import { proxyToVite, wireWebsocketProxy } from './http/proxy.js';
+import { WasmServerModule } from './runtime/module.js';
+const DEFAULT_MAX_BODY_LENGTH = 1024 * 1024 * 8;
+const VITE_PREFIXES = ['/@', '/node_modules/', '/__toil/'];
+const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.txt': 'text/plain; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.gif': 'image/gif',
+    '.ico': 'image/x-icon',
+    '.wasm': 'application/wasm',
+    '.woff2': 'font/woff2',
+};
+function isViteInternal(url) {
+    return VITE_PREFIXES.some((p) => url.startsWith(p));
+}
+function resolveSendfile(root, file) {
+    const resolved = path.resolve(root, file);
+    if (resolved !== root && !resolved.startsWith(root + path.sep))
+        return null;
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile())
+        return null;
+    return resolved;
+}
+async function toEnvelopeRequest(request) {
+    const hasBody = request.method !== 'GET' && request.method !== 'HEAD';
+    const body = hasBody ? new Uint8Array(await request.buffer()) : new Uint8Array(0);
+    const xff = request.headers['x-forwarded-for'];
+    const clientIp = typeof xff === 'string' && xff.length > 0 ? xff.split(',')[0].trim() : '127.0.0.1';
+    return {
+        method: request.method,
+        path: request.url,
+        headers: Object.entries(request.headers),
+        body,
+        clientIp,
+    };
+}
+function sendWasmResponse(response, root, result) {
+    response.status(result.status);
+    let hasContentType = false;
+    for (const [name, value] of result.headers) {
+        if (name.toLowerCase() === 'content-type')
+            hasContentType = true;
+        response.header(name, value);
+    }
+    response.header('server', 'toil-dev');
+    if (result.sendfile !== null) {
+        const file = resolveSendfile(root, result.sendfile);
+        if (file === null) {
+            response.status(404).send('not found\n');
+            return;
+        }
+        if (!hasContentType) {
+            response.header('content-type', MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream');
+        }
+        response.sendFile(file);
+        return;
+    }
+    if (!hasContentType)
+        response.header('content-type', 'text/plain; charset=utf-8');
+    response.send(Buffer.from(result.body.buffer, result.body.byteOffset, result.body.length));
+}
+export async function startDevServer(options) {
+    const host = options.host ?? '127.0.0.1';
+    const root = path.resolve(options.root);
+    const emailInit = initEmailService(root, options.email);
+    if (emailInit.service !== null) {
+        process.stdout.write(pc.dim(`  ✉ email enabled: ${emailInit.note}`) + '\n');
+    }
+    else if (emailInit.note !== null) {
+        process.stdout.write(pc.yellow('  ! ') + pc.dim(`email off: ${emailInit.note}`) + '\n');
+    }
+    const module = new WasmServerModule(options.wasmFile);
+    configureDbPersistence(path.join(root, '.toil', 'devdata.json'));
+    let warnedMissing = false;
+    let loadedOnce = false;
+    const refresh = () => {
+        try {
+            if (module.refresh() && loadedOnce) {
+                process.stdout.write(pc.green('  ✓ ') + pc.dim('server module reloaded') + '\n');
+            }
+            loadedOnce ||= module.available;
+        }
+        catch (e) {
+            process.stdout.write(pc.red(`  ✗ server wasm failed to load: ${String(e)}`) + '\n');
+        }
+        if (!module.available && !warnedMissing) {
+            warnedMissing = true;
+            process.stdout.write(pc.yellow('  ! ') +
+                pc.dim(`server wasm not found at ${options.wasmFile}; serving client only`) +
+                '\n');
+        }
+    };
+    refresh();
+    const app = new Server({
+        max_body_length: options.maxBodyLength ?? DEFAULT_MAX_BODY_LENGTH,
+        max_body_buffer: 1024 * 32,
+        fast_abort: true,
+    });
+    app.set_error_handler((_request, response, error) => {
+        if (response.completed)
+            return;
+        response.atomic(() => {
+            response.status(500).send(`internal error: ${error.message}\n`);
+        });
+    });
+    wireWebsocketProxy(app, options.vite);
+    app.any('/*', async (request, response) => {
+        response.removeHeader('uWebSockets');
+        const dispatchable = !isViteInternal(request.url) && METHOD_CODES[request.method] !== undefined;
+        if (dispatchable)
+            refresh();
+        if (dispatchable && module.available) {
+            const envelopeReq = await toEnvelopeRequest(request);
+            const cacheHost = request.headers.host ?? 'dev';
+            const hasAuth = request.headers.cookie !== undefined || request.headers.authorization !== undefined;
+            const cached = lookupCache(cacheHost, request.method, request.url, envelopeReq.body);
+            if (cached !== null) {
+                sendWasmResponse(response, root, cached);
+                return;
+            }
+            try {
+                const result = module.dispatch(envelopeReq);
+                if (!result.unhandled) {
+                    const finalized = applyCacheRule(cacheHost, request.method, request.url, envelopeReq.body, hasAuth, result);
+                    sendWasmResponse(response, root, finalized);
+                    return;
+                }
+            }
+            catch (e) {
+                process.stdout.write(pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) +
+                    '\n');
+                response.status(500).send('internal error\n');
+                return;
+            }
+        }
+        await proxyToVite(request, response, options.vite);
+    });
+    await app.listen(options.port, host);
+    return {
+        port: options.port,
+        host,
+        close: async () => {
+            await app.shutdown();
+        },
+    };
+}

package/docs/time.md

@@ -11,7 +11,7 @@ from `toiljs/server/runtime`.
 ```ts
 import { Time } from 'toiljs/server/runtime'; // optional; Time is also a global
 
-const ms = Time.nowMillis();   // i64 milliseconds since the Unix epoch
+const ms = Time.nowMillis();   // u64 milliseconds since the Unix epoch
 const s  = Time.nowSeconds();  // u64 whole seconds since the Unix epoch
 ```
 
@@ -19,7 +19,7 @@ const s  = Time.nowSeconds();  // u64 whole seconds since the Unix epoch
 
 | Member | Signature | Description |
 | --- | --- | --- |
-| `Time.nowMillis()` | `static nowMillis(): i64` | Milliseconds since the Unix epoch (the raw host `Date.now()` value). |
+| `Time.nowMillis()` | `static nowMillis(): u64` | Milliseconds since the Unix epoch (the raw host `Date.now()` value). |
 | `Time.nowSeconds()` | `static nowSeconds(): u64` | Whole seconds since the epoch (`nowMillis() / 1000`). The unit used by sessions and login challenges. |
 
 ## Semantics

package/examples/basic/server/migrations/GuestEntry.migration.ts

@@ -0,0 +1,39 @@
+/**
+ * A ToilDB data MIGRATION for the guestbook's `GuestEntry` (see ../models/GuestEntry).
+ *
+ * THE CONVENTION: every `@migrate` lives in a `*.migration.ts` file under a
+ * `migrations/` folder (enforced at compile time). The build auto-discovers this
+ * file - nothing imports it - and weaves its transform into `GuestEntry`'s decoder.
+ *
+ * THE STORY: `GuestEntry` started life with just `author` + `message`. Later we
+ * added an `at` timestamp. Without a migration, every entry already written would
+ * fail to decode (its bytes have no `at`). With this file, an OLD entry is decoded
+ * as its original shape and upgraded on READ - lazily, per row, only when touched.
+ * No backfill, no downtime: rows written under the old layout keep working, and a
+ * read rewrites the converged value back so it is paid for at most once.
+ *
+ * Try it under `toiljs dev`: sign the guestbook, then add a field to `GuestEntry`
+ * + extend this transform + rebuild. The entries already on disk (in `.toil/`)
+ * surface their OLD schema_version, so this `@migrate` runs when you `list()` them.
+ */
+
+import { GuestEntry } from '../models/GuestEntry';
+
+/** The ORIGINAL `GuestEntry` layout (v1): no `at` timestamp. Kept so entries on
+ *  disk written under it still decode. One kept shape per past layout. */
+@data
+export class GuestEntryV1 {
+    author: string = '';
+    message: string = '';
+}
+
+/**
+ * Upgrade a v1 entry to the current `GuestEntry`. The DELTA form `(old, into)`
+ * auto-copies the fields the two layouts SHARE (`author`, `message`); we only fill
+ * the field that is new. A migration is a PURE transform - it may not touch the
+ * database (that is a compile error).
+ */
+@migrate
+export function up(old: GuestEntryV1, into: GuestEntry): void {
+    into.at = 0; // unknown for pre-timestamp entries
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "toiljs",
     "type": "module",
-    "version": "0.0.58",
+    "version": "0.0.60",
     "author": "Dacely",
     "description": "The modern React framework: a file-based React frontend and a ToilScript-compiled WebAssembly backend.",
     "repository": {
@@ -131,7 +131,7 @@
         "nodemailer": "^9.0.1",
         "picocolors": "^1.1.1",
         "sharp": "^0.35.2",
-        "toilscript": "^0.1.36",
+        "toilscript": "^0.1.37",
         "typescript-eslint": "^8.61.1",
         "vite": "^8.0.16",
         "vite-imagetools": "^10.0.1",
@@ -144,6 +144,9 @@
         "react-dom": ">=18.0.0",
         "typescript": ">=6.0.0"
     },
+    "overrides": {
+        "elliptic": "file:./stubs/elliptic"
+    },
     "devDependencies": {
         "@babel/core": "^8.0.1",
         "@babel/preset-env": "^8.0.2",

package/server/runtime/time.ts

@@ -17,13 +17,13 @@
 @global
 export class Time {
     /** Milliseconds since the Unix epoch (the host `Date.now()` value). */
-    static nowMillis(): i64 {
-        return <i64>Date.now();
+    static nowMillis(): u64 {
+        return Date.now();
     }
 
     /** Whole seconds since the Unix epoch (`nowMillis() / 1000`), the unit used
      *  for session and challenge timestamps. */
     static nowSeconds(): u64 {
-        return <u64>(Date.now() / 1000);
+        return Date.now() / 1000;
     }
 }