@aalis/api-webui 0.11.1 → 0.13.0

package/dist/frame/frame.css

@@ -0,0 +1,218 @@
+/*
+ * 插件前端的样式基线，托管为 /frames/_base/frame.css，插件前端可选引用：
+ *   <link rel="stylesheet" href="/frames/_base/frame.css">
+ * 只给元素级的样式，不设按类名选的变体。颜色只引用主题令牌（助手收到 init 时写在根元素上，主题变了跟着更新）；
+ * 尺寸写在本文件里，取值与宿主界面相同，触屏与减少动效由本文件自己的媒体查询求值。圆角用 --radius-sm、--radius-md
+ * 两个名字写默认值，宿主以后推入的值写在根元素的内联样式上，盖过这里的默认值。
+ */
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+:root {
+  --radius-sm: 4px;
+  --radius-md: 6px;
+  font-family:
+    system-ui, -apple-system, "Segoe UI", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "Noto Sans CJK SC",
+    sans-serif;
+  font-size: 100%;
+  line-height: 1.375rem;
+  color: var(--color-text);
+  -webkit-text-size-adjust: 100%;
+  text-size-adjust: 100%;
+}
+
+body {
+  margin: 0;
+  padding: 1rem;
+  font-size: 0.875rem;
+  background: var(--color-bg);
+}
+
+h1,
+h2,
+h3 {
+  margin: 0 0 0.5rem;
+  font-size: 1rem;
+  font-weight: 600;
+  line-height: 1.5rem;
+}
+
+p,
+ul,
+ol,
+table,
+pre {
+  margin: 0 0 0.75rem;
+}
+
+ul,
+ol {
+  padding-left: 1.5rem;
+}
+
+li + li {
+  margin-top: 0.25rem;
+}
+
+a {
+  color: var(--color-accent-text);
+  text-decoration: underline 1px;
+  text-underline-offset: 2px;
+}
+
+/* 焦点环用 outline：Windows 高对比度模式会去掉阴影 */
+:focus-visible {
+  outline: 2px solid var(--color-focus);
+  outline-offset: 2px;
+}
+
+button,
+input,
+select,
+textarea {
+  font: inherit;
+  color: inherit;
+}
+
+/* 按钮只有一种，与宿主的次要按钮一致 */
+button {
+  min-width: 1.75rem;
+  min-height: 1.75rem;
+  padding: 0 0.5rem;
+  border: 0;
+  border-radius: var(--radius-sm);
+  font-size: 0.8125rem;
+  font-weight: 400;
+  line-height: 1.25rem;
+  background: var(--color-fill-2);
+  cursor: pointer;
+  transition: background-color 100ms cubic-bezier(0.2, 0, 0, 1);
+}
+
+/* 只写底色：简写 background 会复位 background-clip，触屏上底色就铺进透明边框（见文件末尾） */
+button:hover:not(:disabled) {
+  background-color: var(--color-fill-3);
+}
+
+button:disabled {
+  color: var(--color-text-disabled);
+  cursor: default;
+}
+
+input:not([type="checkbox"]):not([type="radio"]),
+select,
+textarea {
+  min-height: 1.75rem;
+  padding: 0 0.75rem;
+  font-size: 0.875rem;
+  background: transparent;
+  border: 1px solid var(--color-border-control);
+  border-radius: var(--radius-sm);
+}
+
+textarea {
+  padding: 0.5rem 0.75rem;
+}
+
+input:focus-visible,
+select:focus-visible,
+textarea:focus-visible {
+  outline-offset: 0;
+}
+
+::placeholder {
+  color: var(--color-text-3);
+}
+
+input[type="checkbox"],
+input[type="radio"] {
+  accent-color: var(--color-accent);
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.8125rem;
+  line-height: 1.25rem;
+}
+
+th,
+td {
+  height: 2.25rem;
+  padding: 0 0.75rem;
+  border-bottom: 1px solid var(--color-border);
+  text-align: left;
+}
+
+th {
+  height: 2rem;
+  font-size: 0.75rem;
+  font-weight: 500;
+  color: var(--color-text-2);
+}
+
+code,
+kbd,
+pre {
+  font-family: ui-monospace, "SF Mono", "JetBrains Mono", "Cascadia Mono", Menlo, Consolas, monospace;
+}
+
+:not(pre) > code {
+  padding: 0 0.25rem;
+  border-radius: var(--radius-sm);
+  font-size: 0.9em;
+  background: var(--color-fill-2);
+}
+
+pre {
+  padding: 0.75rem;
+  overflow-x: auto;
+  border-radius: var(--radius-md);
+  font-size: 0.8125rem;
+  line-height: 1.25rem;
+  background: var(--color-fill-1);
+}
+
+/*
+ * 触屏：点按范围 44 像素。按钮外面一圈 0.25rem 的透明边框占排版位置，底色只画到边框以内，看得见的是 36 像素；
+ * 圆角加上边框宽，里面的角仍是 --radius-sm；焦点环往回收到看得见的框外 2 像素。
+ * 输入框 44 像素高，字号不小于 16 像素，免得 iOS 聚焦时放大整页
+ */
+@media (pointer: coarse) {
+  button {
+    min-width: 2.75rem;
+    min-height: 2.75rem;
+    border: 0.25rem solid transparent;
+    border-radius: calc(var(--radius-sm) + 0.25rem);
+    background-clip: padding-box;
+  }
+
+  button:focus-visible {
+    outline-offset: -2px;
+  }
+
+  input:not([type="checkbox"]):not([type="radio"]),
+  select {
+    min-height: 2.75rem;
+  }
+
+  input:not([type="checkbox"]):not([type="radio"]),
+  select,
+  textarea {
+    font-size: 1rem;
+  }
+
+  td {
+    height: 3rem;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  button {
+    transition: none;
+  }
+}

package/dist/frame/frame.js

@@ -0,0 +1,158 @@
+// 插件前端的助手，托管为 /frames/_base/frame.js。片段里的 nonce 原样读出、不清：清片段会往会话历史里加条目，
+// nonce 对框架自己本来也不保密。同一页上的框架都是不透明来源、能互相发窗口消息，但只有父文档发得出来源是
+// window.parent 的消息，所以只认来自它、带端口的第一个 init，之后只用这个端口。主题令牌、这个插件的字典与 <html lang>
+// 在收到 init 的同一拍写上，框架显示出来时已是宿主的配色与语言。导入的 schema-i18n 构建时换成随本包带的那一份
+// （/frames/_base/schema-i18n/，见 build.mjs）
+import { fingerprint, normalizeLanguages, pickLanguage, registerCatalogEntry, resolveSource, resolveText, } from './schema-i18n/index.js';
+/** 与 api-webui 的 FRAME_PROTOCOL_VERSION 同值：助手随 api-webui 同版本发布 */
+const PROTOCOL = '1.1';
+/** 发出 hello 之后等 init 的时长 */
+const INIT_TIMEOUT_MS = 10_000;
+function applyTheme({ kind, tokens }) {
+    const root = document.documentElement;
+    for (const [name, value] of Object.entries(tokens))
+        root.style.setProperty(name, value);
+    root.dataset.theme = kind;
+    root.style.colorScheme = kind;
+}
+/** 宿主给的服务进程时区：认不出的（不按协议的宿主）当作没给，免得插件拿去格式化时抛错 */
+function zoneOf(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    try {
+        new Intl.DateTimeFormat('en', { timeZone: value });
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 语言包给这个插件补的译文：只认 language、text、from 都是字符串的条目，形状不对的丢掉，与宿主一侧同一读法。按协议的宿主
+ * 交来的已经筛过；不按协议的宿主交来坏条目时，握手照样完成，t() 也不因它抛错
+ */
+function packed(packs) {
+    if (typeof packs !== 'object' || packs === null)
+        return {};
+    return Object.fromEntries(Object.entries(packs).map(([key, candidates]) => [
+        key,
+        (Array.isArray(candidates) ? candidates : []).filter((candidate) => typeof candidate?.language === 'string' &&
+            typeof candidate.text === 'string' &&
+            typeof candidate.from === 'string'),
+    ]));
+}
+/**
+ * 登记这个插件的字典，按字典实际选中的语言设 <html lang>（原文、字典自带的译文与原文指纹相符的语言包补充里，按语言链选），
+ * 回这个语言与 t()。次版本更早的宿主不给这几项，插件也可以没有字典：这时 t() 回键名，lang 不动，语言为 undefined
+ */
+function translator({ languages, texts, packs }, timeZone) {
+    if (!texts || !registerCatalogEntry(texts))
+        return { t: key => key };
+    const chain = Array.isArray(languages) ? languages : [];
+    const supplied = packed(packs);
+    // 标签按规范写法比与写（目录里登记的也是规范写法），不照抄宿主给的大小写
+    const tags = [texts.language, ...Object.keys(texts.locales)];
+    for (const [key, candidates] of Object.entries(supplied)) {
+        const from = Object.hasOwn(texts.source, key) ? fingerprint(texts.source[key]) : undefined;
+        for (const { language, from: given } of candidates)
+            if (given === from)
+                tags.push(language);
+    }
+    const offered = normalizeLanguages(tags);
+    const language = offered[chain.length > 0 ? (pickLanguage(chain, offered) ?? 0) : 0];
+    document.documentElement.lang = language;
+    const options = { packs: new Map([[texts.ns, new Map(Object.entries(supplied))]]), timeZone };
+    return {
+        language,
+        t: (key, params) => {
+            const ref = { i18n: texts.ns, key, ...(params && { params }), source: key };
+            return chain.length > 0 ? resolveText(ref, chain, options) : resolveSource(ref, options);
+        },
+    };
+}
+function connected(port, given) {
+    const pending = new Map();
+    const invalidated = new Set();
+    const changed = new Set();
+    let lastId = 0;
+    const send = (message) => port.postMessage(message);
+    function request(message) {
+        lastId += 1;
+        const id = lastId;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            send({ ...message, id });
+        });
+    }
+    function listen(listeners, listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+    }
+    port.onmessage = ({ data }) => {
+        if (data.type === 'result') {
+            const waiting = pending.get(data.id);
+            pending.delete(data.id);
+            if (data.ok)
+                waiting?.resolve(data.value);
+            else
+                waiting?.reject(Object.assign(new Error(data.error.message), { code: data.error.code }));
+        }
+        else if (data.type === 'theme') {
+            applyTheme(data);
+        }
+        else if (data.type === 'invalidate') {
+            for (const listener of invalidated)
+                listener(data.source);
+        }
+        else if (data.type === 'sessions.changed') {
+            for (const listener of changed)
+                listener({ upserts: data.upserts, removes: data.removes });
+        }
+    };
+    addEventListener('pagehide', () => send({ type: 'leaving' }));
+    return {
+        ...given,
+        data: (source, input) => request({ type: 'data', source, ...(input && { input }) }),
+        action: (action, input) => request({ type: 'action', action, ...(input && { input }) }),
+        open: async (target) => {
+            await request({ type: 'open', target });
+        },
+        onInvalidate: listener => listen(invalidated, listener),
+        listSessions: params => request({ type: 'sessions.list', ...params }),
+        onSessionsChanged: listener => listen(changed, listener),
+        abortTurn: async (params) => {
+            await request({ type: 'turn.abort', ...params });
+        },
+    };
+}
+function handshake() {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            removeEventListener('message', onInit);
+            reject(new Error('宿主没有回应握手'));
+        }, INIT_TIMEOUT_MS);
+        function onInit(event) {
+            if (event.source !== parent || event.ports.length !== 1 || event.data?.type !== 'init')
+                return;
+            removeEventListener('message', onInit);
+            clearTimeout(timer);
+            const { theme, sessionId, timeZone } = event.data;
+            if (typeof theme?.tokens !== 'object' || theme.tokens === null) {
+                reject(new Error('宿主的 init 不合格：theme 要是带 tokens 的对象'));
+                return;
+            }
+            applyTheme(theme);
+            const zone = zoneOf(timeZone);
+            resolve(connected(event.ports[0], { sessionId, timeZone: zone, ...translator(event.data, zone) }));
+        }
+        addEventListener('message', onInit);
+        const hello = { type: 'hello', protocol: PROTOCOL, nonce: location.hash.slice(1) };
+        parent.postMessage(hello, '*');
+    });
+}
+let connection;
+/** 与宿主握手，拿到这一页的连接；调多次是同一个连接 */
+export function connect() {
+    connection ??= handshake();
+    return connection;
+}

package/dist/frame/schema-i18n/catalog.js

@@ -0,0 +1,101 @@
+// 进程级目录：各包的原文字典登记在这里，解析时按 ns 查。
+//
+// 目录放在 globalThis[Symbol.for('aalis.i18n.catalog')]，进程里装了几份本包（第三方插件带的嵌套副本）都共用它，
+// 所以目录与条目的形状是跨副本的协议：目录是 { entries: Map<ns, 条目>, issues: 冲突[] }，
+// 条目是 { v: 1, ns, language, source, locales }，只放字符串表，不放函数与解析结果。
+// 条目结构有破坏性改动时升 v；解析遇到不认识的 v 退回 text.source。
+import { canonicalLanguage } from './locale.js';
+const SLOT = Symbol.for('aalis.i18n.catalog');
+function catalog() {
+    const global = globalThis;
+    global[SLOT] ??= { entries: new Map(), issues: [] };
+    return global[SLOT];
+}
+function isCurrent(entry) {
+    return entry?.v === 1;
+}
+/** 表里的一条：只认自有的字符串值 */
+export function entryText(table, key) {
+    const text = Object.hasOwn(table, key) ? table[key] : undefined;
+    return typeof text === 'string' ? text : undefined;
+}
+/** 本版协议的条目，没登记或版本不认识时 undefined */
+export function catalogEntry(ns) {
+    const entry = catalog().entries.get(ns);
+    return isCurrent(entry) ? entry : undefined;
+}
+/** 补入 from 里 into 没有的键；同键不同文记一条冲突。没有新键时返回 into 本身 */
+function mergeTable(into, from, conflict, issues) {
+    let merged;
+    for (const key of Object.keys(from)) {
+        const text = entryText(from, key);
+        if (text === undefined)
+            continue;
+        const existing = entryText(into, key);
+        if (existing === undefined) {
+            merged ??= { ...into };
+            merged[key] = text;
+        }
+        else if (existing !== text) {
+            issues.push(conflict(key));
+        }
+    }
+    return merged ?? into;
+}
+/** 登记一个字典。同一 ns 再次登记按键合并：已有键保留先登记的，新键补入，冲突记进目录（库本身不打日志） */
+export function registerTexts(entry) {
+    const { entries, issues } = catalog();
+    const { ns, language } = entry;
+    const existing = entries.get(ns);
+    if (existing === undefined) {
+        entries.set(ns, { v: 1, ...entry });
+        return;
+    }
+    if (!isCurrent(existing)) {
+        issues.push({ ns, kind: 'version' });
+        return;
+    }
+    if (existing.language !== language) {
+        issues.push({ ns, kind: 'language', language });
+        return;
+    }
+    const source = mergeTable(existing.source, entry.source, key => ({ ns, kind: 'source', key }), issues);
+    const locales = { ...existing.locales };
+    for (const [tag, table] of Object.entries(entry.locales)) {
+        locales[tag] = mergeTable(locales[tag] ?? {}, table, key => ({ ns, kind: 'locale', language: tag, key }), issues);
+    }
+    entries.set(ns, { ...existing, source: source, locales });
+}
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isStringTable = (value) => isRecord(value) && Object.values(value).every(text => typeof text === 'string');
+/**
+ * 登记外来的目录条目（前端构建时写下的、插件前端随 init 收到的，都是 {@link CatalogEntry} 写成的 JSON）：按本版协议核形状——
+ * v 为 1，ns 是非空字符串，语言标签合法、规范化后不重复，原文与各语言译文表的值都是字符串——语言标签规范化；不合的整条
+ * 不登记，回 false。同一 ns 已登记时与 defineTexts 一样按键合并
+ */
+export function registerCatalogEntry(value) {
+    if (!isRecord(value) || value.v !== 1 || typeof value.ns !== 'string' || value.ns === '')
+        return false;
+    const language = typeof value.language === 'string' ? canonicalLanguage(value.language) : undefined;
+    const { source, locales } = value;
+    if (language === undefined || !isStringTable(source) || !isRecord(locales))
+        return false;
+    const tables = {};
+    for (const [tag, table] of Object.entries(locales)) {
+        const canonical = canonicalLanguage(tag);
+        if (canonical === undefined || Object.hasOwn(tables, canonical) || !isStringTable(table))
+            return false;
+        tables[canonical] = table;
+    }
+    registerTexts({ ns: value.ns, language, source, locales: tables });
+    return true;
+}
+/** 目录里本版协议的全部字典 */
+export function catalogEntries() {
+    return [...catalog().entries.values()].filter(isCurrent);
+}
+/** 目录记下的冲突（副本） */
+export function catalogIssues() {
+    return [...catalog().issues];
+}
+//# sourceMappingURL=catalog.js.map

package/dist/frame/schema-i18n/check.js

@@ -0,0 +1,65 @@
+// 字典自检：第三方在单测里一行调用 `expect(checkTexts(t)).toEqual([])`，第一方由守卫调用
+import { entryText } from './catalog.js';
+import { incompatibleParams, paramKinds, parseMessage } from './message.js';
+/** 引号里形如参数的写法：奇数个撇号接 {名} 或 {名, */
+const QUOTED_ARGUMENT = /(?:^|[^'])(?:'')*'\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*[},]/g;
+/** 会按 Markdown 转义的参数（字符串原样渲染的那几种）紧挨着反引号 */
+function argumentInBackticks(message) {
+    return message.some((part, i) => {
+        if (typeof part === 'string' || part.type === 'pound')
+            return false;
+        if (part.type === 'plural' || part.type === 'select')
+            return [...part.branches.values()].some(argumentInBackticks);
+        if (part.type !== 'plain' && part.type !== 'list' && part.type !== 'lines')
+            return false;
+        const before = message[i - 1];
+        const after = message[i + 1];
+        return (typeof before === 'string' && before.endsWith('`')) || (typeof after === 'string' && after.startsWith('`'));
+    });
+}
+/** 检查一个字典（defineTexts 返回的 t()，或目录里的条目） */
+export function checkTexts(domain) {
+    const issues = [];
+    const locales = Object.entries(domain.locales);
+    for (const [key, template] of Object.entries(domain.source)) {
+        const source = parseMessage(template);
+        const expected = source && paramKinds(source);
+        const check = (language, text, message) => {
+            if (expected && [...text.matchAll(QUOTED_ARGUMENT)].some(match => expected.has(match[1]))) {
+                issues.push({ kind: 'quote', language, key });
+            }
+            if (argumentInBackticks(message))
+                issues.push({ kind: 'code', language, key });
+        };
+        if (source && expected) {
+            const conflicting = [...expected].filter(([, accepts]) => accepts === 0).map(([name]) => name);
+            if (conflicting.length > 0)
+                issues.push({ kind: 'params', language: domain.language, key, params: conflicting });
+            check(domain.language, template, source);
+        }
+        else {
+            issues.push({ kind: 'parse', language: domain.language, key });
+        }
+        for (const [language, table] of locales) {
+            const text = entryText(table, key);
+            if (text === undefined)
+                continue;
+            const message = parseMessage(text);
+            if (!message) {
+                issues.push({ kind: 'parse', language, key });
+                continue;
+            }
+            const params = expected ? incompatibleParams(expected, message) : [];
+            if (params.length > 0)
+                issues.push({ kind: 'params', language, key, params });
+            check(language, text, message);
+        }
+    }
+    for (const [language, table] of locales) {
+        const keys = Object.keys(domain.source).filter(key => entryText(table, key) === undefined);
+        if (keys.length > 0)
+            issues.push({ kind: 'missing', language, keys });
+    }
+    return issues;
+}
+//# sourceMappingURL=check.js.map

package/dist/frame/schema-i18n/define.js

@@ -0,0 +1,105 @@
+// 原文字典与译文的声明：defineTexts 登记字典、返回按键产出文字对象的 t()；defineLocale 在编译期核译文
+import { catalogEntry, entryText, registerTexts } from './catalog.js';
+import { formatMessage } from './format.js';
+import { canonicalLanguage } from './locale.js';
+import { parseMessage } from './message.js';
+import { listSeparator } from './resolve.js';
+import { isTextRef } from './text-ref.js';
+function languageTag(tag, ns) {
+    const canonical = canonicalLanguage(tag);
+    if (canonical === undefined)
+        throw new RangeError(`${ns}：语言标签不合法：${tag}`);
+    return canonical;
+}
+/**
+ * 声明一个包的原文字典并登记进进程级目录。ns 写包名；language 与 locales 的键过 `Intl.getCanonicalLocales`，非法即抛。
+ * source 写成 `as const` 的对象（或就地写字面量），t() 才推得出参数；locales 的值用 {@link defineLocale} 写
+ */
+export function defineTexts(definition) {
+    const { ns } = definition;
+    const source = definition.source;
+    const domain = {
+        ns,
+        language: languageTag(definition.language, ns),
+        source,
+        locales: Object.fromEntries(Object.entries(definition.locales ?? {}).map(([tag, table]) => [languageTag(tag, ns), table])),
+    };
+    registerTexts(domain);
+    const t = (key, given) => {
+        const template = entryText(source, key);
+        if (template === undefined)
+            throw new RangeError(`${ns} 的原文字典里没有键 ${key}`);
+        // 复制一层（数组也复制）：调用方之后改自己的对象或数组，文字对象不跟着变
+        const params = given &&
+            Object.fromEntries(Object.entries(given).map(([name, value]) => [name, Array.isArray(value) ? [...value] : value]));
+        return { i18n: ns, key, ...(params && { params }), source: renderSource(template, params, domain.language) };
+    };
+    return Object.assign(t, domain);
+}
+/** 按原文渲染整句，参数里的文字对象取各自的 source；渲染失败时为原文模板原样 */
+function renderSource(template, params, language) {
+    const message = parseMessage(template);
+    const options = { language, nested: (text) => text.source, listSeparator: () => listSeparator(language) };
+    return (message && formatMessage(message, params ?? {}, options)) ?? template;
+}
+/** value 的前 max 个码点，不从代理对中间切开 */
+function headOf(value, max) {
+    if (value.length <= max)
+        return value;
+    let end = 0;
+    let count = 0;
+    for (const char of value) {
+        if (count++ === max)
+            break;
+        end += char.length;
+    }
+    return value.slice(0, end);
+}
+/** 截完以后参数里字符串的总字数上限是 max 的这么多倍 */
+const TOTAL_FACTOR = 16;
+/** 参数里字符串的总字数（含参数里的文字对象与列表元素）；嵌套文字对象各自渲染好的 source 不算，它们由参数推出 */
+function paramChars(text) {
+    let total = 0;
+    const count = (value) => {
+        if (typeof value === 'string')
+            total += value.length;
+        else if (isTextRef(value))
+            total += paramChars(value);
+    };
+    for (const value of Object.values(text.params ?? {})) {
+        if (Array.isArray(value))
+            value.forEach(count);
+        else
+            count(value);
+    }
+    return total;
+}
+/**
+ * 把文字对象里的字符串参数（含参数里的文字对象与列表元素）逐个截到 max 个码点，不从代理对中间切开；source 按截后的参数
+ * 重新按原文渲染。所属字典不在目录里时 source 也截到 max，没有参数的也截；在目录里且没有参数的原样返回。
+ * 截完参数里字符串的总字数仍超过 max 的 16 倍（几十条以上带长参数的分句、上百行）时，退为截到 max 的原文字符串。
+ * 落盘方用它给参数里可能带着上游整段报错的文字对象封顶，存它的地方本来就收 `string | TextRef`
+ */
+export function truncateParams(text, max) {
+    const cut = cutParams(text, max);
+    return paramChars(cut) > max * TOTAL_FACTOR ? headOf(cut.source, max) : cut;
+}
+function cutParams(text, max) {
+    const entry = catalogEntry(text.i18n);
+    const template = entry && entryText(entry.source, text.key);
+    if (text.params === undefined)
+        return template === undefined ? { ...text, source: headOf(text.source, max) } : text;
+    const cut = (value) => typeof value === 'string' ? headOf(value, max) : isTextRef(value) ? cutParams(value, max) : value;
+    const params = Object.fromEntries(Object.entries(text.params).map(([name, value]) => [name, Array.isArray(value) ? value.map(cut) : cut(value)]));
+    const source = entry && template !== undefined ? renderSource(template, params, entry.language) : headOf(text.source, max);
+    return { ...text, params, source };
+}
+/**
+ * 声明一种语言的译文：`defineLocale<Source>()({ … })`，就地写对象字面量。原文里没有的键、不是字面量的译文、
+ * 参数与原文不兼容的译文（原文 `{count}` 而译文用 plural：数量参数在原文里也要写成 `{count, number}` 或 plural）
+ * 编译报错；缺的键允许
+ */
+export function defineLocale() {
+    return entries => entries;
+}
+//# sourceMappingURL=define.js.map

package/dist/frame/schema-i18n/errors.js

@@ -0,0 +1,41 @@
+import { isTextRef } from './text-ref.js';
+/**
+ * 给人看的错误：message 是 `text.source`（日志照旧可读），出口按读者语言渲染 `text`；`status` 是 HTTP 出口用的状态码。
+ * 判定用 {@link isTextError}，不用 instanceof：进程里装了两份本包时，两份的类互不认得
+ */
+export class TextError extends Error {
+    name = 'TextError';
+    text;
+    constructor(text, options = {}) {
+        super(text.source, 'cause' in options ? { cause: options.cause } : undefined);
+        this.text = text;
+        if (options.status !== undefined)
+            this.status = options.status;
+    }
+}
+/**
+ * 给任意 Error 挂上文字对象并返回它本身，name 与类不变（ConfigError、SessionSettingsError 这类按 name 判定的错误照旧认得）。
+ * message 不动，由调用方给（通常就是 `text.source`）
+ */
+export function withText(error, text) {
+    return Object.assign(error, { text });
+}
+/** 是不是挂着文字对象的错误：按结构判（Error 且 `text` 是文字对象），另一份包的 TextError、改了 name 的子类都认 */
+export function isTextError(error) {
+    return error instanceof Error && isTextRef(error.text);
+}
+/** 接住的报错作参数用：有文字对象取它，否则 message，再否则 String(err)。不要取 `.message` 拼句 */
+export function textOf(error) {
+    if (isTextError(error))
+        return error.text;
+    const message = error?.message;
+    if (typeof message === 'string')
+        return message;
+    try {
+        return String(error);
+    }
+    catch {
+        return Object.prototype.toString.call(error);
+    }
+}
+//# sourceMappingURL=errors.js.map