@ternkit/tern 1.1.0 → 1.2.1

package/dist/server/web.js

@@ -0,0 +1,395 @@
+// Web APIs that Svelte libraries commonly touch while rendering, for the
+// server renderer. QuickJS implements only the language; Node, which runs
+// SvelteKit's renderer, has all of these. Each is installed only where it is
+// missing.
+//
+// Browser-only objects (window, document, navigator, location) are left
+// undefined on purpose: libraries check for them to decide whether they are
+// running in a browser.
+// TextEncoder and TextDecoder (UTF-8).
+export class TextEncoderPolyfill {
+    encoding = 'utf-8';
+    encode(input = '') {
+        const out = [];
+        for (const ch of String(input)) {
+            let c = ch.codePointAt(0);
+            if (c >= 0xd800 && c <= 0xdfff)
+                c = 0xfffd;
+            if (c < 0x80)
+                out.push(c);
+            else if (c < 0x800)
+                out.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+            else if (c < 0x10000)
+                out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+            else
+                out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+        }
+        return new Uint8Array(out);
+    }
+    encodeInto(input, dest) {
+        const bytes = this.encode(input);
+        const n = Math.min(bytes.length, dest.length);
+        dest.set(bytes.subarray(0, n));
+        return {
+            read: n === bytes.length ? input.length : new TextDecoderPolyfill().decode(bytes.subarray(0, n)).length,
+            written: n
+        };
+    }
+}
+export class TextDecoderPolyfill {
+    encoding;
+    fatal;
+    ignoreBOM;
+    constructor(label = 'utf-8', options = {}) {
+        const l = String(label).toLowerCase();
+        if (l !== 'utf-8' && l !== 'utf8' && l !== 'unicode-1-1-utf-8')
+            throw new RangeError(`TextDecoder: unsupported encoding "${label}"`);
+        this.encoding = 'utf-8';
+        this.fatal = !!options.fatal;
+        this.ignoreBOM = !!options.ignoreBOM;
+    }
+    decode(input) {
+        if (input === undefined)
+            return '';
+        const b = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+        let out = '';
+        let i = !this.ignoreBOM && b[0] === 0xef && b[1] === 0xbb && b[2] === 0xbf ? 3 : 0;
+        const bad = () => {
+            if (this.fatal)
+                throw new TypeError('TextDecoder: invalid UTF-8');
+            out += '�';
+        };
+        while (i < b.length) {
+            const x = b[i];
+            let n;
+            let c;
+            if (x < 0x80)
+                [n, c] = [0, x];
+            else if (x >= 0xc2 && x < 0xe0)
+                [n, c] = [1, x & 31];
+            else if (x >= 0xe0 && x < 0xf0)
+                [n, c] = [2, x & 15];
+            else if (x >= 0xf0 && x < 0xf5)
+                [n, c] = [3, x & 7];
+            else {
+                bad();
+                i++;
+                continue;
+            }
+            // The WHATWG decoder: a malformed sequence becomes one U+FFFD
+            // covering its lead byte and the continuation bytes that were valid.
+            let k = 1;
+            for (; k <= n; k++) {
+                const y = b[i + k];
+                const lo = k === 1 ? (x === 0xe0 ? 0xa0 : x === 0xf0 ? 0x90 : 0x80) : 0x80;
+                const hi = k === 1 ? (x === 0xed ? 0x9f : x === 0xf4 ? 0x8f : 0xbf) : 0xbf;
+                if (y === undefined || y < lo || y > hi)
+                    break;
+                c = (c << 6) | (y & 63);
+            }
+            if (k <= n) {
+                bad();
+                i += k;
+                continue;
+            }
+            out += String.fromCodePoint(c);
+            i += n + 1;
+        }
+        return out;
+    }
+}
+// Event, CustomEvent and EventTarget.
+export class EventPolyfill {
+    type;
+    bubbles;
+    cancelable;
+    composed;
+    timeStamp = Date.now();
+    defaultPrevented = false;
+    target = null;
+    currentTarget = null;
+    /** @internal */
+    _stop = false;
+    constructor(type, init = {}) {
+        this.type = String(type);
+        this.bubbles = !!init.bubbles;
+        this.cancelable = !!init.cancelable;
+        this.composed = !!init.composed;
+    }
+    preventDefault() {
+        if (this.cancelable)
+            this.defaultPrevented = true;
+    }
+    stopPropagation() { }
+    stopImmediatePropagation() {
+        this._stop = true;
+    }
+}
+export class CustomEventPolyfill extends EventPolyfill {
+    detail;
+    constructor(type, init = {}) {
+        super(type, init);
+        this.detail = init.detail ?? null;
+    }
+}
+export class EventTargetPolyfill {
+    #listeners = new Map();
+    addEventListener(type, fn, options) {
+        if (!fn)
+            return;
+        const opts = typeof options === 'object' ? options : {};
+        if (opts.signal?.aborted)
+            return;
+        const list = this.#listeners.get(type) ?? [];
+        if (list.some((l) => l.fn === fn))
+            return;
+        list.push({ fn, once: !!opts.once });
+        this.#listeners.set(type, list);
+        opts.signal?.addEventListener('abort', () => this.removeEventListener(type, fn));
+    }
+    removeEventListener(type, fn) {
+        const list = this.#listeners.get(type);
+        if (list)
+            this.#listeners.set(type, list.filter((l) => l.fn !== fn));
+    }
+    dispatchEvent(event) {
+        event.target = this;
+        event.currentTarget = this;
+        for (const l of [...(this.#listeners.get(event.type) ?? [])]) {
+            if (l.once)
+                this.removeEventListener(event.type, l.fn);
+            if (typeof l.fn === 'function')
+                l.fn.call(this, event);
+            else
+                l.fn.handleEvent(event);
+            if (event._stop)
+                break;
+        }
+        event.currentTarget = null;
+        return !event.defaultPrevented;
+    }
+}
+export class AbortSignalPolyfill extends EventTargetPolyfill {
+    aborted = false;
+    reason = undefined;
+    onabort = null;
+    throwIfAborted() {
+        if (this.aborted)
+            throw this.reason;
+    }
+    static abort(reason) {
+        const c = new AbortControllerPolyfill();
+        c.abort(reason);
+        return c.signal;
+    }
+    static timeout() {
+        return new AbortSignalPolyfill(); // timers never fire during a render
+    }
+    static any(signals) {
+        const c = new AbortControllerPolyfill();
+        for (const s of signals) {
+            if (s.aborted) {
+                c.abort(s.reason);
+                break;
+            }
+            s.addEventListener('abort', () => c.abort(s.reason), { once: true });
+        }
+        return c.signal;
+    }
+}
+export class AbortControllerPolyfill {
+    signal = new AbortSignalPolyfill();
+    abort(reason) {
+        const s = this.signal;
+        if (s.aborted)
+            return;
+        s.aborted = true;
+        s.reason =
+            reason ??
+                Object.assign(new Error('This operation was aborted'), {
+                    name: 'AbortError'
+                });
+        const e = new EventPolyfill('abort');
+        s.onabort?.(e);
+        s.dispatchEvent(e);
+    }
+}
+/** Installs every missing API on g (globalThis in the renderer). */
+export function install(g) {
+    const define = (name, value) => {
+        if (typeof g[name] === 'undefined') {
+            Object.defineProperty(g, name, {
+                value,
+                writable: true,
+                configurable: true,
+                enumerable: false
+            });
+        }
+    };
+    // Timers. A render is synchronous and its HTML is sent when it returns, so a
+    // timer set during rendering could not change the output; in Node it would
+    // fire after the response was sent. Callbacks are dropped, not kept, so they
+    // cannot hold memory across renders.
+    {
+        let next = 1;
+        const set = () => next++;
+        const clear = () => { };
+        define('setTimeout', set);
+        define('setInterval', set);
+        define('setImmediate', set);
+        define('clearTimeout', clear);
+        define('clearInterval', clear);
+        define('clearImmediate', clear);
+        define('requestAnimationFrame', undefined);
+    }
+    // performance.now(), for libraries that measure or seed with it.
+    {
+        const origin = Date.now();
+        define('performance', {
+            timeOrigin: origin,
+            now: () => Date.now() - origin,
+            mark: () => undefined,
+            measure: () => undefined,
+            getEntriesByName: () => [],
+            getEntriesByType: () => [],
+            clearMarks: () => { },
+            clearMeasures: () => { }
+        });
+    }
+    // atob and btoa.
+    {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+        define('btoa', (input) => {
+            const s = String(input);
+            let out = '';
+            for (let i = 0; i < s.length; i += 3) {
+                const codes = [s.charCodeAt(i), s.charCodeAt(i + 1), s.charCodeAt(i + 2)];
+                for (const c of codes)
+                    if (c > 255)
+                        throw new Error('btoa: the string contains characters outside of Latin1');
+                const [a, b, c] = codes;
+                const n = (a << 16) | ((b || 0) << 8) | (c || 0);
+                out +=
+                    chars[n >> 18] + chars[(n >> 12) & 63] + (i + 1 < s.length ? chars[(n >> 6) & 63] : '=') + (i + 2 < s.length ? chars[n & 63] : '=');
+            }
+            return out;
+        });
+        define('atob', (input) => {
+            let s = String(input).replace(/[\t\n\f\r ]/g, '');
+            if (s.length % 4 === 0)
+                s = s.replace(/==?$/, '');
+            if (s.length % 4 === 1 || /[^A-Za-z0-9+/]/.test(s))
+                throw new Error('atob: the string is not correctly encoded');
+            let out = '';
+            let bits = 0;
+            let acc = 0;
+            for (const ch of s) {
+                acc = (acc << 6) | chars.indexOf(ch);
+                bits += 6;
+                if (bits >= 8) {
+                    bits -= 8;
+                    out += String.fromCharCode((acc >> bits) & 255);
+                }
+            }
+            return out;
+        });
+    }
+    // crypto.getRandomValues and crypto.randomUUID, from Go's crypto/rand.
+    {
+        const getRandomValues = (array) => {
+            if (!array)
+                return array;
+            const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+            if (bytes.length > 65536)
+                throw new Error('getRandomValues: at most 65536 bytes');
+            if (typeof __tern_random === 'function') {
+                const hex = __tern_random(bytes.length);
+                for (let i = 0; i < bytes.length; i++)
+                    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+            }
+            else {
+                for (let i = 0; i < bytes.length; i++)
+                    bytes[i] = Math.floor(Math.random() * 256);
+            }
+            return array;
+        };
+        const randomUUID = () => {
+            const b = getRandomValues(new Uint8Array(16));
+            b[6] = (b[6] & 0x0f) | 0x40;
+            b[8] = (b[8] & 0x3f) | 0x80;
+            const h = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');
+            return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+        };
+        define('crypto', { getRandomValues, randomUUID });
+    }
+    // structuredClone.
+    {
+        const clone = (value, seen) => {
+            if (typeof value !== 'object' || value === null) {
+                if (typeof value === 'function' || typeof value === 'symbol')
+                    throw new Error(`structuredClone: ${typeof value} could not be cloned`);
+                return value;
+            }
+            if (seen.has(value))
+                return seen.get(value);
+            let out;
+            if (value instanceof Date)
+                out = new Date(value.getTime());
+            else if (value instanceof RegExp)
+                out = new RegExp(value.source, value.flags);
+            else if (value instanceof ArrayBuffer)
+                out = value.slice(0);
+            else if (ArrayBuffer.isView(value)) {
+                const C = value.constructor;
+                const buf = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+                out = value instanceof DataView ? new DataView(buf) : new C(buf, 0, value.length);
+            }
+            else if (value instanceof Map) {
+                const m = new Map();
+                seen.set(value, m);
+                for (const [k, v] of value)
+                    m.set(clone(k, seen), clone(v, seen));
+                return m;
+            }
+            else if (value instanceof Set) {
+                const s = new Set();
+                seen.set(value, s);
+                for (const v of value)
+                    s.add(clone(v, seen));
+                return s;
+            }
+            else if (value instanceof Error) {
+                const e = new value.constructor(value.message);
+                if (value.stack)
+                    e.stack = value.stack;
+                out = e;
+            }
+            else if (Array.isArray(value)) {
+                const a = [];
+                seen.set(value, a);
+                value.forEach((v, i) => (a[i] = clone(v, seen)));
+                return a;
+            }
+            else {
+                const o = {};
+                seen.set(value, o);
+                for (const k of Object.keys(value))
+                    o[k] = clone(value[k], seen);
+                return o;
+            }
+            seen.set(value, out);
+            return out;
+        };
+        define('structuredClone', (value) => clone(value, new Map()));
+    }
+    define('TextEncoder', TextEncoderPolyfill);
+    define('TextDecoder', TextDecoderPolyfill);
+    define('Event', EventPolyfill);
+    define('CustomEvent', CustomEventPolyfill);
+    define('EventTarget', EventTargetPolyfill);
+    define('AbortSignal', AbortSignalPolyfill);
+    define('AbortController', AbortControllerPolyfill);
+    // fetch is not available while rendering: in Tern, data comes from Go load
+    // functions. Fail with an explanation instead of "fetch is not defined".
+    define('fetch', () => Promise.reject(new Error('fetch is not available during server rendering. Load data in a Go Load function, or fetch in onMount.')));
+}

package/dist/vite/goscript.d.ts

@@ -0,0 +1,12 @@
+import type { PreprocessorGroup } from 'svelte/compiler';
+import type { Plugin } from 'vite';
+export declare function goScriptEnabled(root: string): boolean;
+/** The names a component's Go code shows in its markup. */
+export declare function exportedNames(source: string): {
+    values: string[];
+    funcs: string[];
+};
+/** Replaces <script lang="go"> with the JavaScript that binds it to Go. */
+export declare function goScriptPreprocessor(getRoot: () => string): PreprocessorGroup;
+/** Builds the Go code at startup and on changes. */
+export declare function goScriptPlugin(getRoot: () => string): Plugin;

package/dist/vite/goscript.js

@@ -0,0 +1,226 @@
+// Experimental <script lang="go"> support: Go component logic compiled to
+// WebAssembly. Enabled with "experimental": { "goScript": true } in
+// tern.json. See docs/experimental-go-script.md.
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+const DIR = '.tern/goscript';
+/** The WebAssembly components' Go packages; live ones are written by tern gen. */
+const WASM_DIR = '.tern/goscript/wasm';
+const GO_SCRIPT = /<script\b([^>]*\blang=["']go["'][^>]*)>([\s\S]*?)<\/script>/;
+export function goScriptEnabled(root) {
+    try {
+        const c = JSON.parse(fs.readFileSync(path.join(root, 'tern.json'), 'utf8'));
+        return c.experimental?.goScript === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** A component's ID: stable for its path, valid in Go and JS. */
+function componentID(root, file) {
+    return 'c' + createHash('sha256').update(path.relative(root, file).split(path.sep).join('/')).digest('hex').slice(0, 10);
+}
+function walk(dir, out = []) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (e.name.startsWith('.') || e.name === 'node_modules')
+            continue;
+        const p = path.join(dir, e.name);
+        if (e.isDirectory())
+            walk(p, out);
+        else if (e.name.endsWith('.svelte'))
+            out.push(p);
+    }
+    return out;
+}
+function scan(root) {
+    const out = [];
+    for (const file of walk(path.join(root, 'src'))) {
+        const text = fs.readFileSync(file, 'utf8');
+        const m = GO_SCRIPT.exec(text);
+        if (!m)
+            continue;
+        const codeStart = m.index + m[0].indexOf('>') + 1;
+        const live = /(^|\s)live(\s|=|$)/.test(m[1]);
+        out.push({ id: componentID(root, file), live, file, source: m[2], line: text.slice(0, codeStart).split('\n').length });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+/** The names a component's Go code shows in its markup. */
+export function exportedNames(source) {
+    const values = [
+        ...source.matchAll(/\b(?:State|Derived)(?:\[[^\]]*\])?\(\s*\w+\s*,\s*"([A-Za-z_$][\w$]*)"/g),
+        ...source.matchAll(/\.Show\(\s*\w+\s*,\s*"([A-Za-z_$][\w$]*)"/g)
+    ].map((m) => m[1]);
+    const funcs = [...source.matchAll(/\.Func\(\s*"([A-Za-z_$][\w$]*)"/g)].map((m) => m[1]);
+    return { values: [...new Set(values)], funcs: [...new Set(funcs)] };
+}
+function modulePath(root) {
+    const mod = /^module\s+(\S+)/m.exec(fs.readFileSync(path.join(root, 'go.mod'), 'utf8'));
+    if (!mod)
+        throw new Error('tern: go.mod has no module line');
+    return mod[1];
+}
+/** Writes the Go packages, builds the WebAssembly module and computes initial states. */
+async function compile(root, wasm) {
+    // Live components run on the server: tern gen compiles them into the app.
+    const comps = scan(root).filter((c) => !c.live);
+    const dir = path.join(root, DIR);
+    const pkgDir = path.join(root, WASM_DIR);
+    fs.rmSync(pkgDir, { recursive: true, force: true });
+    fs.mkdirSync(pkgDir, { recursive: true });
+    if (comps.length === 0) {
+        fs.writeFileSync(path.join(dir, 'initial.json'), '{}');
+        return;
+    }
+    const mod = modulePath(root);
+    let main = '// Code generated by tern from <script lang="go">; DO NOT EDIT.\n\npackage main\n\nimport (\n\t"github.com/Unfield/Tern/goscript"\n';
+    for (const c of comps) {
+        const body = c.source.replace(/^\s*package\s+\w+\s*$/m, '');
+        fs.mkdirSync(path.join(pkgDir, c.id), { recursive: true });
+        // //line makes compile errors point at the .svelte file.
+        fs.writeFileSync(path.join(pkgDir, c.id, 'component.go'), `package ${c.id}\n\n//line ${c.file}:${c.line}\n${body}\n`);
+        main += `\t${c.id} "${mod}/${WASM_DIR}/${c.id}"\n`;
+    }
+    main += ')\n\nfunc main() {\n';
+    for (const c of comps)
+        main += `\tgoscript.Register(${JSON.stringify(c.id)}, ${c.id}.Setup)\n`;
+    main += '\tgoscript.Run()\n}\n';
+    fs.writeFileSync(path.join(pkgDir, 'main.go'), main);
+    const goErr = (e) => {
+        const err = e;
+        return new Error(`tern: compiling <script lang="go">:\n${(err.stderr || err.message).trim()}`);
+    };
+    // Setup runs natively once, so server rendering shows the initial state.
+    try {
+        const { stdout } = await run('go', ['run', './' + WASM_DIR], { cwd: root, maxBuffer: 16 << 20 });
+        fs.writeFileSync(path.join(dir, 'initial.json'), stdout);
+    }
+    catch (e) {
+        throw goErr(e);
+    }
+    if (!wasm)
+        return;
+    try {
+        await run('go', ['build', '-trimpath', '-ldflags=-s -w', '-o', path.join(DIR, 'app.wasm'), './' + WASM_DIR], {
+            cwd: root,
+            env: { ...process.env, GOOS: 'js', GOARCH: 'wasm' }
+        });
+        const { stdout: goroot } = await run('go', ['env', 'GOROOT']);
+        const candidates = ['lib/wasm/wasm_exec.js', 'misc/wasm/wasm_exec.js'].map((p) => path.join(goroot.trim(), p));
+        const execJS = candidates.find((p) => fs.existsSync(p));
+        if (!execJS)
+            throw new Error('tern: wasm_exec.js was not found in GOROOT');
+        fs.copyFileSync(execJS, path.join(dir, 'wasm_exec.js'));
+    }
+    catch (e) {
+        throw goErr(e);
+    }
+}
+function initialState(root, id) {
+    try {
+        const all = JSON.parse(fs.readFileSync(path.join(root, DIR, 'initial.json'), 'utf8'));
+        return all[id] ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Replaces <script lang="go"> with the JavaScript that binds it to Go. */
+export function goScriptPreprocessor(getRoot) {
+    return {
+        name: 'tern-goscript',
+        markup({ content }) {
+            // A live component carries its server-rendered state in the page,
+            // so hydration starts from the same values.
+            const m = GO_SCRIPT.exec(content);
+            if (!m || !/(^|\s)live(\s|=|$)/.test(m[1]))
+                return;
+            return { code: content + '\n<svelte:head>{@html __go.stateScript}</svelte:head>\n' };
+        },
+        script({ content, attributes, filename }) {
+            if (attributes.lang !== 'go' || !filename)
+                return;
+            const root = getRoot();
+            if (!goScriptEnabled(root)) {
+                throw new Error(`${filename}: <script lang="go"> is experimental; enable it with "experimental": { "goScript": true } in tern.json`);
+            }
+            const id = componentID(root, filename);
+            const { values, funcs } = exportedNames(content);
+            const { lang: _lang, live, ...rest } = attributes;
+            if (live) {
+                let code = `
+	import { useLive } from '@ternkit/tern/goscript';
+	let __goProps = $props();
+	const __goUID = $props.id();
+	const __go = useLive(${JSON.stringify(id)}, __goUID, () => ({ ...__goProps }));
+`;
+                for (const v of values)
+                    code += `\tconst ${v} = $derived(__go.state[${JSON.stringify(v)}] as any);\n`;
+                for (const f of funcs)
+                    code += `\tconst ${f} = (...args: unknown[]): any => __go.call(${JSON.stringify(f)}, ...args);\n`;
+                return { code, attributes: { ...rest, lang: 'ts' } };
+            }
+            const base = path.join(root, DIR).split(path.sep).join('/');
+            let code = `
+	import { useGo } from '@ternkit/tern/goscript';
+	import __goWasm from '${base}/app.wasm?url';
+	let __goProps = $props();
+	const __go = useGo(${JSON.stringify(id)}, ${JSON.stringify(initialState(root, id))}, () => import('${base}/wasm_exec.js'), __goWasm, () => ({ ...__goProps }));
+`;
+            for (const v of values)
+                code += `\tconst ${v} = $derived(__go.state[${JSON.stringify(v)}] as any);\n`;
+            for (const f of funcs)
+                code += `\tconst ${f} = (...args: unknown[]): any => __go.call(${JSON.stringify(f)}, ...args);\n`;
+            return { code, attributes: { ...rest, lang: 'ts' } };
+        }
+    };
+}
+/** Builds the Go code at startup and on changes. */
+export function goScriptPlugin(getRoot) {
+    let config;
+    let enabled = false;
+    return {
+        name: 'tern:goscript',
+        configResolved(c) {
+            config = c;
+            enabled = goScriptEnabled(c.root);
+        },
+        async buildStart() {
+            if (!enabled)
+                return;
+            const ssr = !!config.build.ssr;
+            const swBuild = process.env.TERN_SW_BUILD === '1';
+            if (swBuild)
+                return;
+            // The server build only needs the initial state, which the client
+            // build already computed.
+            if (ssr && fs.existsSync(path.join(config.root, DIR, 'initial.json')))
+                return;
+            await compile(config.root, !ssr);
+        },
+        configureServer(server) {
+            if (!enabled)
+                return;
+            let timer;
+            server.watcher.on('change', (file) => {
+                if (!file.endsWith('.svelte') || !GO_SCRIPT.test(fs.readFileSync(file, 'utf8')))
+                    return;
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    compile(config.root, true).then(() => server.ws.send({ type: 'full-reload' }), (e) => server.config.logger.error(e.message));
+                }, 50);
+            });
+        }
+    };
+}

package/dist/vite/index.d.ts

@@ -3,6 +3,12 @@ import type { Plugin } from 'vite';
 export interface TernOptions {
     /** Options passed to @sveltejs/vite-plugin-svelte. */
     svelte?: Partial<SvelteOptions>;
+    /**
+     * Packages to bundle in their "browser" build for server rendering, for
+     * libraries whose default build needs Node APIs such as Buffer while the
+     * browser build is portable. nanoid is included by default.
+     */
+    ssrBrowserBuilds?: string[];
 }
 /**
  * The Vite plugin for Tern apps. It includes the Svelte plugin, so it is