@tiaforge-ui/sinter 0.0.0-stage → 0.2.0

package/dist/compiler/index.d.ts

@@ -0,0 +1,22 @@
+import { compileParts, type CompileOptions, type CompileResult, type CompiledParts, type HelperManifest } from './compile.js';
+export type { CompileOptions, CompileResult, CompiledParts, HelperManifest };
+export type { Diagnostic } from './diagnostics.js';
+export type { CheckUnit } from './check-unit.js';
+export { formatDiagnostic, docsUrl, CODES } from './diagnostics.js';
+export { DIAGNOSTIC_DOCS, type DiagnosticDoc } from './diagnostic-docs.js';
+export { compileParts };
+export declare const PACKAGE = "@tiaforge-ui/sinter";
+/** Compiles annotated HTML into a rewritten page and its page module. Pure and deterministic. */
+export declare function compile(html: string, options: CompileOptions): CompileResult;
+export declare function pageModule(parts: CompiledParts, options: Pick<CompileOptions, 'helpers' | 'dev' | 'config' | 'actions'>): string;
+/**
+ * Reads a helpers module's export names statically. `export * as m from './x.js'`
+ * becomes a namespace whose members are read from `x.js` the same way. `export * from './y.js'`
+ * re-exports (e.g. paraglide's message index) are followed, relative paths only.
+ */
+export declare function readHelperManifest(source: string, options: {
+    module: string;
+    file: string;
+    readFile: (path: string) => string;
+    resolve?: (spec: string, from: string) => string | null;
+}): HelperManifest;

package/dist/compiler/index.js

@@ -0,0 +1,160 @@
+import * as acorn from 'acorn';
+import { tsPlugin } from '@sveltejs/acorn-typescript';
+import { compileParts } from './compile.js';
+export { formatDiagnostic, docsUrl, CODES } from './diagnostics.js';
+export { DIAGNOSTIC_DOCS } from './diagnostic-docs.js';
+export { compileParts };
+export const PACKAGE = '@tiaforge-ui/sinter';
+/** Compiles annotated HTML into a rewritten page and its page module. Pure and deterministic. */
+export function compile(html, options) {
+    const parts = compileParts(html, options);
+    const out = { html: parts.html, module: pageModule(parts, options), diagnostics: parts.diagnostics, files: parts.files };
+    if (parts.check)
+        out.check = parts.check;
+    return out;
+}
+export function pageModule(parts, options) {
+    const lines = [];
+    const core = ['mount', '$k', ...parts.helpers.builtin];
+    lines.push(`import { ${core.join(', ')} } from '${PACKAGE}';`);
+    for (const f of parts.features)
+        lines.push(`import ${f} from '${PACKAGE}/${f}';`);
+    if (parts.helpers.user.length && options.helpers.module) {
+        lines.push(`import { ${parts.helpers.user.join(', ')} } from ${JSON.stringify(options.helpers.module)};`);
+    }
+    for (const [ns, members] of Object.entries(parts.namespaces)) {
+        const mod = options.helpers.namespaces[ns].module;
+        lines.push(`import { ${members.map((m) => `${m} as ${ns}$${m}`).join(', ')} } from ${JSON.stringify(mod)};`);
+    }
+    // actions (`data-sn-call`): imported as `$a$name` / `$a$ns$member`, only those the page calls
+    const acts = options.actions;
+    if (acts?.module) {
+        const direct = parts.calls.filter((c) => !c.includes('.'));
+        if (direct.length)
+            lines.push(`import { ${direct.map((c) => `${c} as $a$${c}`).join(', ')} } from ${JSON.stringify(acts.module)};`);
+        const byNs = new Map();
+        for (const c of parts.calls.filter((x) => x.includes('.'))) {
+            const [ns, member] = c.split('.');
+            byNs.set(ns, [...(byNs.get(ns) ?? []), member]);
+        }
+        for (const [ns, members] of byNs) {
+            lines.push(`import { ${members.map((x) => `${x} as $a$${ns}$${x}`).join(', ')} } from ${JSON.stringify(acts.namespaces[ns].module)};`);
+        }
+    }
+    if (options.config)
+        lines.push(`import ${JSON.stringify(options.config)};`);
+    lines.push('');
+    lines.push(`const ir = ${JSON.stringify(parts.ir)};`);
+    lines.push('const fns = [');
+    for (const f of parts.fns)
+        lines.push(`  ${f},`);
+    lines.push('];');
+    lines.push('');
+    lines.push(`mount(document, { ir, fns, features: [${parts.features.join(', ')}] });`);
+    return lines.join('\n') + '\n';
+}
+/**
+ * Reads a helpers module's export names statically. `export * as m from './x.js'`
+ * becomes a namespace whose members are read from `x.js` the same way. `export * from './y.js'`
+ * re-exports (e.g. paraglide's message index) are followed, relative paths only.
+ */
+export function readHelperManifest(source, options) {
+    const manifest = { module: options.module, names: [], namespaces: {} };
+    const resolve = options.resolve ?? ((spec, from) => (spec.startsWith('.') ? joinPath(from, spec) : null));
+    const read = (file) => {
+        try {
+            return exportsOf(options.readFile(file), file);
+        }
+        catch {
+            return null;
+        }
+    };
+    /** the module's own value exports plus those of its `export *` re-exports, transitively */
+    const valueNames = (file, exports, seen) => {
+        const names = new Set(exports.names);
+        for (const spec of exports.reexports) {
+            const path = spec.startsWith('.') ? resolve(spec, file) : null;
+            if (!path || seen.has(path))
+                continue;
+            seen.add(path);
+            const sub = read(path);
+            if (sub)
+                for (const n of valueNames(path, sub, seen))
+                    names.add(n);
+        }
+        return [...names].sort();
+    };
+    const top = exportsOf(source, options.file);
+    manifest.names = valueNames(options.file, top, new Set([options.file]));
+    for (const [ns, spec] of top.namespaces) {
+        const path = resolve(spec, options.file);
+        const exports = path ? read(path) : null;
+        const members = path && exports ? valueNames(path, exports, new Set([path])) : [];
+        const modSpec = spec.startsWith('.') ? joinPath(options.module, spec) : spec;
+        manifest.namespaces[ns] = { module: modSpec, members };
+    }
+    return manifest;
+}
+/** acorn extended with TypeScript syntax, for `.ts` helper and namespace modules */
+let tsParser = null;
+function parseModule(source, file) {
+    const options = { ecmaVersion: 'latest', sourceType: 'module' };
+    if (!/\.[cm]?tsx?$/.test(file))
+        return acorn.parse(source, options);
+    tsParser ??= acorn.Parser.extend(tsPlugin());
+    return tsParser.parse(source, options);
+}
+/** Value exports only: type-only exports (`export type`, `export interface`, `export { type X }`) are skipped. */
+function exportsOf(source, file) {
+    const ast = parseModule(source, file);
+    const names = [];
+    const namespaces = [];
+    const reexports = [];
+    const typeOnly = (n) => n.exportKind === 'type';
+    for (const st of ast.body) {
+        if (typeOnly(st))
+            continue;
+        if (st.type === 'ExportNamedDeclaration') {
+            const d = st.declaration;
+            if (d?.type === 'FunctionDeclaration' && d.id)
+                names.push(d.id.name);
+            else if (d?.type === 'ClassDeclaration' && d.id)
+                names.push(d.id.name);
+            else if (d?.type === 'TSEnumDeclaration')
+                names.push(d.id.name);
+            else if (d?.type === 'VariableDeclaration') {
+                for (const v of d.declarations)
+                    if (v.id.type === 'Identifier')
+                        names.push(v.id.name);
+            }
+            for (const s of st.specifiers) {
+                if (typeOnly(s))
+                    continue;
+                const exported = s.exported.type === 'Identifier' ? s.exported.name : String(s.exported.value);
+                if (exported !== 'default')
+                    names.push(exported);
+            }
+        }
+        else if (st.type === 'ExportAllDeclaration' && st.exported) {
+            const ns = st.exported.type === 'Identifier' ? st.exported.name : String(st.exported.value);
+            namespaces.push([ns, String(st.source.value)]);
+        }
+        else if (st.type === 'ExportAllDeclaration') {
+            reexports.push(String(st.source.value));
+        }
+    }
+    return { names: [...new Set(names)].sort(), namespaces, reexports };
+}
+function joinPath(from, spec) {
+    const dir = from.slice(0, from.lastIndexOf('/') + 1);
+    const out = [];
+    for (const seg of (dir + spec).split('/')) {
+        if (seg === '.')
+            continue;
+        if (seg === '..')
+            out.pop();
+        else
+            out.push(seg);
+    }
+    return out.join('/');
+}

package/dist/compiler/openapi.d.ts

@@ -0,0 +1,40 @@
+import type { UrlTemplate } from '../ir.js';
+export interface OpenApiSpec {
+    /** absolute path, for messages */
+    file: string;
+    /** the parsed document (OpenAPI 3.0 or 3.1) */
+    doc: unknown;
+}
+export interface OpenApiMatch {
+    spec: number;
+    /** the spec's path key, e.g. `/articles/{slug}` */
+    path: string;
+    /** schema of the response body, or null when the operation has no JSON 2xx response */
+    body: unknown;
+    /** names of the query parameters the operation declares */
+    query: string[];
+    /** schema of the JSON request body, or null */
+    request: unknown;
+}
+export type Method = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export type Json = Record<string, unknown>;
+/** Follows `$ref`s inside the document (`#/components/…`); external refs resolve to null. */
+export declare function deref(doc: unknown, v: unknown, seen?: number): Json | null;
+export declare function matchResource(specs: OpenApiSpec[], src: UrlTemplate): OpenApiMatch | {
+    closest: string | null;
+};
+/** The operation a request with this method and URL template calls. */
+export declare function matchOperation(specs: OpenApiSpec[], src: UrlTemplate, method: Method): OpenApiMatch | {
+    closest: string | null;
+};
+/** Properties an object schema has, through `allOf`, `oneOf` and `anyOf`. */
+export declare function properties(doc: unknown, schema: unknown, seen?: number): Map<string, unknown>;
+/** Walks a dotted path (`data.items`) into a schema: the schema there, or the segment that is missing. */
+export declare function walk(doc: unknown, schema: unknown, path: string): {
+    schema: unknown;
+} | {
+    missing: string;
+    have: string[];
+};
+/** Query parameter names written literally in a URL template's query string. */
+export declare function queryNames(src: UrlTemplate): string[];

package/dist/compiler/openapi.js

@@ -0,0 +1,177 @@
+import { suggest } from './diagnostics.js';
+const INTERP = '\u0000';
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** Follows `$ref`s inside the document (`#/components/…`); external refs resolve to null. */
+export function deref(doc, v, seen = 0) {
+    if (!isObj(v))
+        return null;
+    if (typeof v.$ref !== 'string')
+        return v;
+    if (seen > 32 || !v.$ref.startsWith('#/'))
+        return null;
+    let cur = doc;
+    for (const raw of v.$ref.slice(2).split('/')) {
+        const key = raw.replace(/~1/g, '/').replace(/~0/g, '~');
+        cur = isObj(cur) ? cur[key] : undefined;
+    }
+    return deref(doc, cur, seen + 1);
+}
+/** `/api/x/{…}?a={…}` as text, interpolations replaced by a marker. */
+function flatten(src) {
+    const text = src.map((p) => (typeof p === 'string' ? p : INTERP)).join('');
+    const q = text.indexOf('?');
+    return q < 0 ? { path: text, query: '' } : { path: text.slice(0, q), query: text.slice(q + 1) };
+}
+function serverPrefixes(doc) {
+    const servers = Array.isArray(doc.servers) && doc.servers.length ? doc.servers : [{ url: '/' }];
+    return servers.filter(isObj).map((s) => {
+        const vars = isObj(s.variables) ? s.variables : {};
+        const url = String(s.url ?? '/').replace(/\{([^}]+)\}/g, (_, n) => String(vars[n]?.default ?? ''));
+        return url.replace(/\/+$/, '');
+    });
+}
+const segments = (p) => p.split('/').filter((s, i, a) => !(s === '' && (i === 0 || i === a.length - 1)));
+/** Score of a spec path against the request path segments, or -1. Literal matches beat parameters. */
+function score(specPath, segs) {
+    const want = segments(specPath);
+    if (want.length !== segs.length)
+        return -1;
+    let n = 0;
+    for (let i = 0; i < want.length; i++) {
+        const w = want[i], s = segs[i];
+        if (!w.includes('{')) {
+            if (w !== s)
+                return -1;
+            n += 2;
+            continue;
+        }
+        if (w.replace(/\{[^}]+\}/g, INTERP) === s) {
+            n += 1;
+            continue;
+        }
+        if (s.includes(INTERP))
+            return -1;
+        const re = new RegExp('^' + w.split(/\{[^}]+\}/).map((x) => x.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('[^/]+') + '$');
+        if (!re.test(s))
+            return -1;
+        n += 1;
+    }
+    return n;
+}
+/** The request path after the server prefix, for each spec whose servers it starts with. */
+function relativePaths(doc, path) {
+    const out = [];
+    const origin = /^https?:\/\/[^/]+/i.exec(path)?.[0] ?? '';
+    for (const prefix of serverPrefixes(doc)) {
+        let rest = null;
+        if (/^https?:\/\//i.test(prefix))
+            rest = path.toLowerCase().startsWith(prefix.toLowerCase()) ? path.slice(prefix.length) : null;
+        else {
+            const p = path.slice(origin.length);
+            rest = p.startsWith(prefix) ? p.slice(prefix.length) : null;
+        }
+        if (rest !== null && (rest === '' || rest.startsWith('/')))
+            out.push(rest);
+    }
+    return out;
+}
+export function matchResource(specs, src) {
+    return matchOperation(specs, src, 'get');
+}
+/** The operation a request with this method and URL template calls. */
+export function matchOperation(specs, src, method) {
+    const { path } = flatten(src);
+    let best = null;
+    specs.forEach((spec, i) => {
+        if (!isObj(spec.doc) || !isObj(spec.doc.paths))
+            return;
+        for (const rest of relativePaths(spec.doc, path)) {
+            const segs = segments(rest);
+            for (const [key, item] of Object.entries(spec.doc.paths)) {
+                if (!isObj(item) || !isObj(item[method]))
+                    continue;
+                const s = score(key, segs);
+                if (s >= 0 && (!best || s > best.score))
+                    best = { spec: i, path: key, score: s };
+            }
+        }
+    });
+    if (!best) {
+        const want = path.replace(/^https?:\/\/[^/]+/i, '').split(INTERP).join('{}');
+        const keys = specs.flatMap((s) => (isObj(s.doc) && isObj(s.doc.paths) ? Object.keys(s.doc.paths) : []));
+        const norm = new Map(keys.map((k) => [k.replace(/\{[^}]+\}/g, '{}'), k]));
+        // the request path still carries the server prefix; compare its tails too
+        const tails = want.split('/').map((_, i, a) => '/' + a.slice(i).join('/'));
+        let close;
+        for (const t of tails)
+            if ((close = suggest(t, norm.keys())))
+                break;
+        return { closest: close ? norm.get(close) : null };
+    }
+    const { spec, path: key } = best;
+    const doc = specs[spec].doc;
+    const item = deref(doc, doc.paths[key]);
+    const op = deref(doc, item[method]);
+    const params = [...(Array.isArray(item.parameters) ? item.parameters : []), ...(Array.isArray(op.parameters) ? op.parameters : [])]
+        .map((p) => deref(doc, p)).filter((p) => !!p && p.in === 'query').map((p) => String(p.name));
+    return { spec, path: key, body: responseSchema(doc, op), query: params, request: jsonSchema(doc, deref(doc, op.requestBody)) };
+}
+function responseSchema(doc, op) {
+    const responses = deref(doc, op.responses);
+    if (!responses)
+        return null;
+    const key = Object.keys(responses).filter((k) => /^2(\d\d|XX)$/i.test(k)).sort()[0];
+    return jsonSchema(doc, key ? deref(doc, responses[key]) : null);
+}
+/** The JSON schema of a response or request body object. */
+function jsonSchema(doc, res) {
+    const content = res && isObj(res.content) ? res.content : null;
+    if (!content)
+        return null;
+    const media = Object.keys(content).find((m) => /^application\/json\b/i.test(m)) ?? Object.keys(content).find((m) => /\+json\b/i.test(m));
+    const m = media ? deref(doc, content[media]) : null;
+    return m?.schema ?? null;
+}
+/** Properties an object schema has, through `allOf`, `oneOf` and `anyOf`. */
+export function properties(doc, schema, seen = 0) {
+    const out = new Map();
+    const s = deref(doc, schema);
+    if (!s || seen > 16)
+        return out;
+    if (isObj(s.properties))
+        for (const [k, v] of Object.entries(s.properties))
+            out.set(k, v);
+    for (const key of ['allOf', 'oneOf', 'anyOf']) {
+        if (Array.isArray(s[key]))
+            for (const sub of s[key])
+                for (const [k, v] of properties(doc, sub, seen + 1))
+                    if (!out.has(k))
+                        out.set(k, v);
+    }
+    return out;
+}
+/** Walks a dotted path (`data.items`) into a schema: the schema there, or the segment that is missing. */
+export function walk(doc, schema, path) {
+    let cur = schema;
+    for (const seg of path.split('.')) {
+        const props = properties(doc, cur);
+        if (!props.has(seg))
+            return { missing: seg, have: [...props.keys()] };
+        cur = props.get(seg);
+    }
+    return { schema: cur };
+}
+/** Query parameter names written literally in a URL template's query string. */
+export function queryNames(src) {
+    const { query } = flatten(src);
+    if (!query)
+        return [];
+    return query.split('&').map((kv) => kv.split('=')[0]).filter((k) => k && !k.includes(INTERP)).map((k) => {
+        try {
+            return decodeURIComponent(k);
+        }
+        catch {
+            return k;
+        }
+    });
+}

package/dist/compiler/vocabulary.d.ts

@@ -0,0 +1,12 @@
+export interface AttrDoc {
+    name: string;
+    value: string;
+    doc: string;
+}
+export declare const ATTRIBUTES: AttrDoc[];
+export declare const ON_DOC: AttrDoc;
+export declare const ELEMENTS: Array<{
+    name: string;
+    attrs: string[];
+    doc: string;
+}>;

package/dist/compiler/vocabulary.js

@@ -0,0 +1,39 @@
+// The whole attribute and element vocabulary, with one-line descriptions.
+// The compiler, llms.txt and html-custom-data.json are all built from it.
+export const ATTRIBUTES = [
+    { name: 'state', value: 'object literal', doc: 'declares local reactive state for the element and its subtree' },
+    { name: 'text', value: 'value expression', doc: 'sets textContent; never HTML' },
+    { name: 'attr', value: 'object literal {href: …}', doc: 'literal keys; null/false removes, true sets empty; URL values are checked' },
+    { name: 'class', value: 'object literal {unread: …}', doc: 'toggles each class' },
+    { name: 'style', value: "object literal {'--color': …}", doc: 'sets each property with style.setProperty' },
+    { name: 'show', value: 'value expression', doc: 'toggles the hidden attribute' },
+    { name: 'prop', value: 'object literal', doc: 'sets JS properties; custom elements only' },
+    { name: 'model', value: 'state path', doc: 'two-way binding for form controls' },
+    { name: 'for', value: 'item in list | (item, i) in list', doc: 'repeats a <template> per item' },
+    { name: 'key', value: 'value expression', doc: 'row identity; defaults to the resource key or object identity' },
+    { name: 'if', value: 'value expression', doc: 'renders a <template> while truthy' },
+    { name: 'else', value: '', doc: 'on a <template> directly after an if template' },
+    { name: 'persist', value: 'storage key', doc: 'persists the model or state in localStorage under sn:' },
+    { name: 'get', value: 'URL template', doc: 'GET action; latest wins' },
+    { name: 'post', value: 'URL template', doc: 'POST action' },
+    { name: 'put', value: 'URL template', doc: 'PUT action' },
+    { name: 'patch', value: 'URL template', doc: 'PATCH action' },
+    { name: 'delete', value: 'URL template', doc: 'DELETE action' },
+    { name: 'call', value: 'action call', doc: 'local action: calls a function from the actions module, e.g. pgp.decrypt(msg)' },
+    { name: 'body', value: 'value expression', doc: 'JSON request body; overrides form serialization' },
+    { name: 'trigger', value: 'DOM event name', doc: 'overrides the default trigger' },
+    { name: 'debounce', value: 'milliseconds', doc: 'delays the trigger, resets on each event; without a method, delays the element\'s data-sn-on-* handlers' },
+    { name: 'concurrency', value: 'block | queue | latest', doc: 'mutations only; default block for forms, queue otherwise' },
+    { name: 'optimistic', value: 'handler expression', doc: 'patch/upsert/remove calls applied before the request, rolled back on failure' },
+    { name: 'then', value: 'handler expression', doc: 'runs after a 2xx response; $result = parsed body' },
+    { name: 'catch', value: 'handler expression', doc: 'runs after an error; $error = {status, body, message}' },
+    { name: 'path', value: 'URL patterns /a/:b …', doc: 'on <html>: the path shapes this page is served for; `:name` segments appear read-only in $url' },
+    { name: 'data', value: 'resource name', doc: 'on <script type="application/json"> in <head>: initial data for a resource' },
+];
+export const ON_DOC = { name: 'on-<event>', value: 'handler expression', doc: 'plain event handler, no request; e.g. data-sn-on-click' };
+export const ELEMENTS = [
+    { name: 'sn-resource', attrs: ['name', 'src', 'call', 'each', 'key', 'items', 'total', 'order', 'when', 'paginate', 'page-size', 'size-param', 'cursor', 'direction-param', 'direction-values', 'page-param', 'offset-param', 'type', 'cache'], doc: 'a named, page-wide cache of server data; `cache` (or `cache="10m"`) shows the data from the last page load at once, then revalidates' },
+    { name: 'sn-sync', attrs: ['src'], doc: 'one server event stream' },
+    { name: 'sn-event', attrs: ['name', 'resource', 'op', 'item', 'set', 'when', 'fallback', 'type'], doc: 'maps one server event to a change message; child of <sn-sync>' },
+    { name: 'sn-include', attrs: ['src'], doc: 'inlines a partial at build time' },
+];

package/dist/dev.d.ts

@@ -0,0 +1,10 @@
+import type { Feature } from './runtime/app.js';
+/**
+ * The HTTP version the origin of `url` was reached over, from Resource Timing: the page's
+ * navigation for a same-origin URL, else the latest request to that origin. An open stream has
+ * no entry of its own until it ends. Null when unknown (no request yet, or a cross-origin
+ * server without `Timing-Allow-Origin`).
+ */
+export declare function protocolOf(url: string, base: string, perf?: Pick<Performance, 'getEntriesByType'> | undefined): string | null;
+declare const dev: Feature;
+export default dev;

package/dist/dev.js

@@ -0,0 +1,92 @@
+/** Messages for the core's warning codes; `%` takes the next argument. */
+const MESSAGES = {
+    1: 'duplicate `data-sn="%"`; not bound',
+    2: 'missing `data-sn="%"`; not bound',
+    3: '`data-sn="%"` is on <%>, expected <%>; not bound',
+    4: 'embedded data for `%` must be a <script> in <head>; ignored',
+    5: 'embedded data for `%` is not valid JSON; ignored',
+    6: 'binding `%` on <%> threw: %',
+    7: 'refused URL in `%` on <%>: %',
+    8: 'refused style value for `%`: %',
+    9: 'model on <%> could not be set: %',
+    10: 'a `data-sn-for` over primitive values needs `data-sn-key`',
+    11: 'duplicate key in `data-sn-for`: %',
+    12: 'resource `%`: `items` path `%` is not an array',
+    13: 'resource `%`: duplicate key `%`; the last one wins',
+    14: 'resource `%`: item is missing key field `%`',
+    15: 'state `%` changed outside sinter: use `update()`',
+    16: 'unhandled error%: %',
+    17: 'resource `%`: src could not be resolved: %',
+    18: 'stream `%` is served over HTTP/1.1, where browsers allow 6 connections per origin: with more than 5 tabs of this app open, pages stop loading. Serve it over HTTP/2 (any TLS reverse proxy such as nginx or Caddy), or use the WebSocket transport',
+    19: 'resource `%`: % KB of data is over the page-load cache limit of 256 KB per entry; not cached',
+};
+/**
+ * The HTTP version the origin of `url` was reached over, from Resource Timing: the page's
+ * navigation for a same-origin URL, else the latest request to that origin. An open stream has
+ * no entry of its own until it ends. Null when unknown (no request yet, or a cross-origin
+ * server without `Timing-Allow-Origin`).
+ */
+export function protocolOf(url, base, perf = globalThis.performance) {
+    let origin;
+    try {
+        origin = new URL(url, base).origin;
+    }
+    catch {
+        return null;
+    }
+    const entries = [...(perf?.getEntriesByType?.('navigation') ?? []), ...(perf?.getEntriesByType?.('resource') ?? []).slice().reverse()];
+    for (const e of entries) {
+        let o;
+        try {
+            o = new URL(e.name).origin;
+        }
+        catch {
+            continue;
+        }
+        if (o === origin && e.nextHopProtocol)
+            return e.nextHopProtocol;
+    }
+    return null;
+}
+function deepFreeze(v) {
+    if (v && typeof v == 'object' && !Object.isFrozen(v)) {
+        Object.freeze(v);
+        for (const k of Object.keys(v))
+            deepFreeze(v[k]);
+    }
+    return v;
+}
+const dev = {
+    name: 'dev',
+    install(app) {
+        const seen = new Set();
+        app.dev = true;
+        app.warn = (code, ...args) => {
+            let i = 0;
+            const text = typeof code == 'string' ? code : MESSAGES[code].replace(/%/g, () => String(args[i++]).replace(/\x1f/g, ','));
+            const msg = `sinter: ${text}`;
+            if (seen.has(msg))
+                return;
+            seen.add(msg);
+            (code == 16 ? console.error : console.warn)(msg, ...args.slice(i));
+        };
+        app.prep = deepFreeze;
+        app.streamOpened = (url) => {
+            if (/^http\/1\./i.test(protocolOf(url, app.env.href()) ?? ''))
+                app.warn(18, url);
+        };
+        const json = (o) => { try {
+            return JSON.stringify(o);
+        }
+        catch {
+            return '';
+        } };
+        let last = [];
+        app.beforeFlush.push((dirty) => app.states.forEach(([sid, obj], i) => {
+            if (json(obj) != last[i] && !dirty.some((p) => p[0] == '$s' + sid))
+                app.warn(15, Object.keys(obj).join('`, `'));
+        }));
+        app.afterFlush.push(() => { last = app.states.map(([, obj]) => json(obj)); });
+    },
+};
+export default dev;

package/dist/each.d.ts

@@ -0,0 +1,3 @@
+import type { Feature } from './runtime/app.js';
+declare const each: Feature;
+export default each;