@huanlin/dsh-plugin-interpreters 0.1.0

package/lib/types/client/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * dsh-interpreters — browser half.
+ *
+ * Registers the `interpreters` card into the shell-declared
+ * `settings.plugin.item` slot (the plugin-config settings page — id
+ * `dsh-interpreters`, order 50, after the upstream bash / agent-loop /
+ * web-search cards). The card's store reads/writes the `interpreters` config
+ * through the host gateway `/api/interpreters/get|set` RPC channel, and keeps
+ * fresh on pushed invalidations.
+ *
+ * Export discipline: the client half value-imports ONLY the frozen platform
+ * module table (CLIENT_EXTERNALS); every other `@deepseek-ai/*` import is
+ * type-only (erased at build) — values arrive via cordis injection
+ * (`ctx.get('connection')`, slot inject faces).
+ *
+ * @module @huanlin/dsh-plugin-interpreters/client
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import { type InterpretersKey } from './locales.ts';
+export type { InterpretersCardInjected, InterpretersCardProps } from './InterpretersCard.tsx';
+export type { InterpretersKey } from './locales.ts';
+export type { InterpretersCardState, InterpretersCardController } from './store.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The interpreters card copy. */
+        'interpreters': InterpretersKey;
+    }
+}
+/** Required services (cordis fiber inject). The target slot is declared by
+ *  ui-plugin-config's apply, whose activation order relative to this one is
+ *  NOT constrained; registration depends on the slot through `slots.inject()`. */
+export declare const inject: string[];
+/**
+ * Register the interpreters card once the `settings.plugin.item` declaration
+ * is on the ledger, wire its store to the connection, and keep it fresh on
+ * every pushed invalidation.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;

package/lib/types/client/index.js

@@ -0,0 +1,72 @@
+/**
+ * dsh-interpreters — browser half.
+ *
+ * Registers the `interpreters` card into the shell-declared
+ * `settings.plugin.item` slot (the plugin-config settings page — id
+ * `dsh-interpreters`, order 50, after the upstream bash / agent-loop /
+ * web-search cards). The card's store reads/writes the `interpreters` config
+ * through the host gateway `/api/interpreters/get|set` RPC channel, and keeps
+ * fresh on pushed invalidations.
+ *
+ * Export discipline: the client half value-imports ONLY the frozen platform
+ * module table (CLIENT_EXTERNALS); every other `@deepseek-ai/*` import is
+ * type-only (erased at build) — values arrive via cordis injection
+ * (`ctx.get('connection')`, slot inject faces).
+ *
+ * @module @huanlin/dsh-plugin-interpreters/client
+ */
+import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react';
+import { InterpretersCard } from "./InterpretersCard.js";
+import { InterpretersCardController, refreshIfLoaded } from "./store.js";
+import { en, NS, zh } from "./locales.js";
+/** Required services (cordis fiber inject). The target slot is declared by
+ *  ui-plugin-config's apply, whose activation order relative to this one is
+ *  NOT constrained; registration depends on the slot through `slots.inject()`. */
+export const inject = ['slots', 'locale', 'connection'];
+/**
+ * Register the interpreters card once the `settings.plugin.item` declaration
+ * is on the ledger, wire its store to the connection, and keep it fresh on
+ * every pushed invalidation.
+ * @param ctx - client root context.
+ */
+export function apply(ctx) {
+    ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-interpreters: dictionaries');
+    // The store reads/writes the interpreters config over the plugin's
+    // self-hosted HTTP route (`/interpreters/api/get` + `/interpreters/api/set`).
+    const controller = new InterpretersCardController();
+    const useSnapshot = bindSnapshotSelector(controller.store);
+    // Pushed invalidations converge the open surface without polling. The dsh
+    // snapshot removed the `settings/changed` host passthrough from the client
+    // runtime Events vocabulary, so convergence rides `connection/reset` — a
+    // connection reset invalidates the whole client state. A burst of resets
+    // coalesces into a single refetch via the microtask debounce, and
+    // `refreshIfLoaded` keeps an unopened card idle.
+    ctx.effect(() => {
+        let pending = false;
+        const refresh = () => {
+            if (pending)
+                return;
+            pending = true;
+            queueMicrotask(() => {
+                pending = false;
+                refreshIfLoaded(controller);
+            });
+        };
+        const disposers = [ctx.on('connection/reset', refresh)];
+        return () => { for (const dispose of disposers)
+            dispose(); };
+    }, 'dsh-interpreters: pushed invalidations');
+    // The card registers into the plugin-config page's card slot with the
+    // upstream card shape — generator + `yield`, `locale: NS`, and an inject
+    // face carrying ONLY the business surface (controller + useSnapshot). The
+    // typed `t` seat is synthesized by the renderer from `locale: NS`.
+    ctx.slots.inject('settings.plugin.item', function* () {
+        yield ctx.slots.register({
+            name: 'settings.plugin.item',
+            id: 'dsh-interpreters',
+            order: 50, // bash 0 / agent-loop 10 / web-search 20 / advisor 30 / interpreters 50
+            locale: NS,
+            inject: () => ({ controller, useSnapshot }),
+        }, InterpretersCard);
+    });
+}

package/lib/types/client/locales.d.ts

@@ -0,0 +1,13 @@
+/**
+ * locales.ts — i18n dictionaries for the interpreters configuration card.
+ *
+ * Keys cover both the card chrome (replicated from upstream PluginCard:
+ * expand/collapse/unsaved/saveFailed/readOnly/save/saving/discard) and the
+ * plugin's own copy (title/intro + the three field labels and hints).
+ *
+ * @module dsh-interpreters/client/locales
+ */
+export declare const NS: "interpreters";
+export type InterpretersKey = 'title' | 'intro' | 'pythonPath' | 'pythonHelp' | 'nodePath' | 'nodeHelp' | 'timeoutMs' | 'timeoutHelp' | 'save' | 'saving' | 'discard' | 'unsaved' | 'saveFailed' | 'readOnly' | 'expand' | 'collapse' | 'namespaceUnavailable' | 'retry';
+export declare const zh: Record<InterpretersKey, string>;
+export declare const en: Record<InterpretersKey, string>;

package/lib/types/client/locales.js

@@ -0,0 +1,50 @@
+/**
+ * locales.ts — i18n dictionaries for the interpreters configuration card.
+ *
+ * Keys cover both the card chrome (replicated from upstream PluginCard:
+ * expand/collapse/unsaved/saveFailed/readOnly/save/saving/discard) and the
+ * plugin's own copy (title/intro + the three field labels and hints).
+ *
+ * @module dsh-interpreters/client/locales
+ */
+export const NS = 'interpreters';
+export const zh = {
+    title: '解释器路径',
+    intro: '配置 run_python / run_node 工具使用的解释器路径。',
+    pythonPath: 'Python 可执行文件路径',
+    pythonHelp: '模型通过 run_python 工具调用该路径执行 Python 代码。留空使用系统默认 python。',
+    nodePath: 'Node.js 可执行文件路径',
+    nodeHelp: '模型通过 run_node 工具调用该路径执行 Node.js 代码。留空使用系统默认 node。',
+    timeoutMs: '执行超时（毫秒）',
+    timeoutHelp: '超过该时长进程将被强制终止。',
+    save: '保存',
+    saving: '保存中…',
+    discard: '放弃修改',
+    unsaved: '未保存',
+    saveFailed: '本部署没有接受这些值，已保留供你修改。',
+    readOnly: '本部署的设置为只读。',
+    expand: '展开设置',
+    collapse: '收起设置',
+    namespaceUnavailable: '解释器配置通道当前不可用。请稍后重试。',
+    retry: '重试',
+};
+export const en = {
+    title: 'Interpreter paths',
+    intro: 'Configure the interpreter executables used by the run_python / run_node tools.',
+    pythonPath: 'Python executable path',
+    pythonHelp: 'The model uses this path to execute Python code via the run_python tool. Leave empty to use the system default python.',
+    nodePath: 'Node.js executable path',
+    nodeHelp: 'The model uses this path to execute Node.js code via the run_node tool. Leave empty to use the system default node.',
+    timeoutMs: 'Execution timeout (ms)',
+    timeoutHelp: 'The process is killed after this duration.',
+    save: 'Save',
+    saving: 'Saving…',
+    discard: 'Discard',
+    unsaved: 'Unsaved',
+    saveFailed: 'The deployment did not accept these values; they were left for you to correct.',
+    readOnly: 'This deployment stores settings read-only.',
+    expand: 'Show settings',
+    collapse: 'Hide settings',
+    namespaceUnavailable: 'The interpreter configuration channel is unavailable. Please retry later.',
+    retry: 'Retry',
+};

package/lib/types/client/store.d.ts

@@ -0,0 +1,88 @@
+/**
+ * store.ts — the interpreters card's staged form over the
+ * `/interpreters/api/get|set` HTTP route.
+ *
+ * The DSH settings RPC domain only serves allowlisted namespaces to
+ * configuration clients, so this store reads and writes the `interpreters`
+ * namespace through the plugin's self-hosted HTTP route
+ * (`fetch('/interpreters/api/get'|'set')`) instead of the host's typertRemote
+ * dispatch. State publishes through a `SnapshotStore` so the card binds a
+ * selector hook via `bindSnapshotSelector`; the store tracks load status,
+ * the staged draft, and the apply lifecycle (idle/saving/saved/error).
+ *
+ * @module dsh-interpreters/client/store
+ */
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+/** The persisted shape of the `interpreters` namespace. */
+export interface InterpretersSettings {
+    pythonPath?: string;
+    nodePath?: string;
+    timeoutMs?: number;
+}
+/** Apply lifecycle states (mirrors advisor-store's ApplyState shape). */
+export type ApplyState = {
+    kind: 'idle';
+} | {
+    kind: 'saving';
+} | {
+    kind: 'saved';
+} | {
+    kind: 'error';
+    message: string;
+};
+/** Card state published through the snapshot store. */
+export interface InterpretersCardState {
+    /** 'idle' before the first load fires; 'loading' while in flight; 'ready' once seeded. */
+    status: 'idle' | 'loading' | 'ready';
+    /** False until the first successful load gates `connection/reset` refreshes. */
+    loaded: boolean;
+    /** False while the namespace is not served to this client; the card renders the unavailable notice. */
+    available: boolean;
+    /** Whether the Host document accepts writes. */
+    writable: boolean;
+    /** Staged draft (last-known host config + local edits). */
+    draft: InterpretersSettings;
+    /** Whether the form holds edits that a save would write. */
+    dirty: boolean;
+    /** Apply lifecycle. */
+    applyState: ApplyState;
+}
+/** A number field renders empty when the section carries none. */
+declare function formatNumber(value: unknown): string;
+/** A text field renders the empty string when absent. */
+declare function formatText(value: unknown): string;
+/**
+ * The card's staged form over the interpreters settings.
+ *
+ * The store publishes through a `SnapshotStore` because slot components read
+ * through a snapshot selector; both the HTTP read and the local drafts
+ * change underneath, and every projection is rebuilt from the two together.
+ */
+export declare class InterpretersCardController {
+    readonly store: SnapshotStore<InterpretersCardState>;
+    /** True after the first successful load; gates `connection/reset` refreshes. */
+    loaded: boolean;
+    private generation;
+    private staged;
+    constructor();
+    /**
+     * Read the resolved config from the Host HTTP route and publish it.
+     * @returns settlement after the read.
+     */
+    load(): Promise<void>;
+    /** Stage draft text for one field. */
+    edit(field: keyof InterpretersSettings, text: string): void;
+    /** Drop every staged edit. */
+    discard(): void;
+    /** Write every staged edit, then re-seed from what the Host accepted. */
+    save(): void;
+    private doSave;
+    /** The staged edits as one patch (only changed fields). */
+    private patchOf;
+}
+/** Refresh the store only after its first load (background invalidation gate). */
+export declare function refreshIfLoaded(controller: InterpretersCardController): void;
+/** Format helpers exposed for the card component. */
+export declare const formatFieldText: typeof formatText;
+export declare const formatFieldNumber: typeof formatNumber;
+export {};

package/lib/types/client/store.js

@@ -0,0 +1,196 @@
+/**
+ * store.ts — the interpreters card's staged form over the
+ * `/interpreters/api/get|set` HTTP route.
+ *
+ * The DSH settings RPC domain only serves allowlisted namespaces to
+ * configuration clients, so this store reads and writes the `interpreters`
+ * namespace through the plugin's self-hosted HTTP route
+ * (`fetch('/interpreters/api/get'|'set')`) instead of the host's typertRemote
+ * dispatch. State publishes through a `SnapshotStore` so the card binds a
+ * selector hook via `bindSnapshotSelector`; the store tracks load status,
+ * the staged draft, and the apply lifecycle (idle/saving/saved/error).
+ *
+ * @module dsh-interpreters/client/store
+ */
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+/** Initial empty state. */
+function initialState() {
+    return {
+        status: 'idle',
+        loaded: false,
+        available: false,
+        writable: false,
+        draft: {},
+        dirty: false,
+        applyState: { kind: 'idle' },
+    };
+}
+/** A number field renders empty when the section carries none. */
+function formatNumber(value) {
+    return typeof value === 'number' ? String(value) : '';
+}
+/** A text field renders the empty string when absent. */
+function formatText(value) {
+    return typeof value === 'string' ? value : '';
+}
+/**
+ * The card's staged form over the interpreters settings.
+ *
+ * The store publishes through a `SnapshotStore` because slot components read
+ * through a snapshot selector; both the HTTP read and the local drafts
+ * change underneath, and every projection is rebuilt from the two together.
+ */
+export class InterpretersCardController {
+    store;
+    /** True after the first successful load; gates `connection/reset` refreshes. */
+    loaded = false;
+    generation = 0;
+    staged = new Map();
+    constructor() {
+        this.store = createSnapshotStore(initialState());
+        void this.load();
+    }
+    /**
+     * Read the resolved config from the Host HTTP route and publish it.
+     * @returns settlement after the read.
+     */
+    async load() {
+        const gen = ++this.generation;
+        this.store.update((s) => { s.status = 'loading'; });
+        let config;
+        try {
+            const response = await fetch('/interpreters/api/get', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: '{}',
+            });
+            if (response.ok) {
+                const parsed = await response.json().catch(() => null);
+                if (parsed?.ok === true && parsed.value !== undefined) {
+                    config = parsed.value.config;
+                }
+            }
+        }
+        catch {
+            // Channel unreachable: leave the card unavailable; not a hard error.
+        }
+        if (gen !== this.generation)
+            return;
+        if (config === undefined) {
+            this.store.update((s) => {
+                s.status = 'ready';
+                s.available = false;
+                s.writable = false;
+            });
+            return;
+        }
+        this.loaded = true;
+        this.staged.clear();
+        this.store.update((s) => {
+            s.status = 'ready';
+            s.available = true;
+            s.writable = true;
+            s.draft = { ...config };
+            s.dirty = false;
+            s.applyState = { kind: 'idle' };
+        });
+    }
+    /** Stage draft text for one field. */
+    edit(field, text) {
+        this.staged.set(field, text);
+        this.store.update((s) => {
+            s.draft = { ...s.draft, [field]: text };
+            s.dirty = true;
+            s.applyState = { kind: 'idle' };
+        });
+    }
+    /** Drop every staged edit. */
+    discard() {
+        if (this.staged.size === 0) {
+            this.store.update((s) => { s.applyState = { kind: 'idle' }; });
+            return;
+        }
+        this.staged.clear();
+        // Re-seed draft from the last-known host config (drop local edits).
+        void this.load();
+    }
+    /** Write every staged edit, then re-seed from what the Host accepted. */
+    save() {
+        void this.doSave();
+    }
+    async doSave() {
+        const gen = ++this.generation;
+        const patch = this.patchOf();
+        if (Object.keys(patch).length === 0) {
+            this.staged.clear();
+            this.store.update((s) => { s.dirty = false; s.applyState = { kind: 'idle' }; });
+            return;
+        }
+        this.store.update((s) => { s.applyState = { kind: 'saving' }; });
+        try {
+            const response = await fetch('/interpreters/api/set', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ patch }),
+            });
+            if (gen !== this.generation)
+                return;
+            if (!response.ok) {
+                const parsed = await response.json().catch(() => null);
+                const message = parsed?.error?.message ?? `HTTP ${response.status}`;
+                this.store.update((s) => { s.applyState = { kind: 'error', message }; });
+                return;
+            }
+            const parsed = await response.json().catch(() => null);
+            if (parsed?.ok !== true || parsed.value === undefined) {
+                const message = parsed?.error?.message ?? 'unknown error';
+                this.store.update((s) => { s.applyState = { kind: 'error', message }; });
+                return;
+            }
+            const next = parsed.value.config;
+            this.staged.clear();
+            this.store.update((s) => {
+                s.draft = { ...next };
+                s.dirty = false;
+                s.applyState = { kind: 'saved' };
+            });
+        }
+        catch (error) {
+            if (gen !== this.generation)
+                return;
+            this.store.update((s) => {
+                s.applyState = { kind: 'error', message: error instanceof Error ? error.message : String(error) };
+            });
+        }
+    }
+    /** The staged edits as one patch (only changed fields). */
+    patchOf() {
+        const patch = {};
+        for (const [field, text] of this.staged) {
+            const value = parseField(field, text);
+            if (value === undefined)
+                continue;
+            patch[field] = value;
+        }
+        return patch;
+    }
+}
+/** Parse one field's draft text into a stored value; the empty string clears. */
+function parseField(field, text) {
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return '';
+    if (field === 'timeoutMs') {
+        const parsed = Number(trimmed);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return trimmed;
+}
+/** Refresh the store only after its first load (background invalidation gate). */
+export function refreshIfLoaded(controller) {
+    if (controller.loaded)
+        void controller.load();
+}
+/** Format helpers exposed for the card component. */
+export const formatFieldText = formatText;
+export const formatFieldNumber = formatNumber;

package/lib/types/config.d.ts

@@ -0,0 +1,32 @@
+/**
+ * config.ts — composition-layer schema, resolved config shape, and resolver.
+ *
+ * The composition `Config` (cordis.patch.yml) is the first-boot seed; the
+ * settings user layer composes on top of it at runtime. `resolveConfig`
+ * normalises any combination of partial source values (composition, user
+ * layer, or both) into a fully-populated {@link ResolvedConfig} the tool
+ * registration and gateway can consume.
+ *
+ * @module dsh-interpreters/config
+ */
+import z from 'schemastery';
+/** Composition + user-layer config shape (all fields optional at the boundary). */
+export interface Config {
+    pythonPath?: string;
+    nodePath?: string;
+    timeoutMs?: number;
+}
+/** Fully-resolved config with fallbacks applied; what the tools and gateway serve. */
+export interface ResolvedConfig {
+    pythonPath: string;
+    nodePath: string;
+    timeoutMs: number;
+}
+/** Schemastery schema for the composition entry and the `interpreters` settings namespace. */
+export declare const Config: z<Config>;
+/**
+ * Resolve config with fallbacks for missing / invalid values.
+ * @param config - raw config from cordis.yml or settings scope.
+ * @returns a fully-populated {@link ResolvedConfig}.
+ */
+export declare function resolveConfig(config: Config): ResolvedConfig;

package/lib/types/config.js

@@ -0,0 +1,29 @@
+/**
+ * config.ts — composition-layer schema, resolved config shape, and resolver.
+ *
+ * The composition `Config` (cordis.patch.yml) is the first-boot seed; the
+ * settings user layer composes on top of it at runtime. `resolveConfig`
+ * normalises any combination of partial source values (composition, user
+ * layer, or both) into a fully-populated {@link ResolvedConfig} the tool
+ * registration and gateway can consume.
+ *
+ * @module dsh-interpreters/config
+ */
+import z from 'schemastery';
+/** Schemastery schema for the composition entry and the `interpreters` settings namespace. */
+export const Config = z.object({
+    pythonPath: z.string().default('python').description('Path to the Python interpreter executable.'),
+    nodePath: z.string().default('node').description('Path to the Node.js interpreter executable.'),
+    timeoutMs: z.number().default(30000).description('Maximum execution time in milliseconds before the process is killed.'),
+});
+/**
+ * Resolve config with fallbacks for missing / invalid values.
+ * @param config - raw config from cordis.yml or settings scope.
+ * @returns a fully-populated {@link ResolvedConfig}.
+ */
+export function resolveConfig(config) {
+    const pythonPath = typeof config.pythonPath === 'string' && config.pythonPath !== '' ? config.pythonPath : 'python';
+    const nodePath = typeof config.nodePath === 'string' && config.nodePath !== '' ? config.nodePath : 'node';
+    const timeoutMs = typeof config.timeoutMs === 'number' && config.timeoutMs > 0 ? config.timeoutMs : 30000;
+    return { pythonPath, nodePath, timeoutMs };
+}

package/lib/types/gateway.d.ts

@@ -0,0 +1,63 @@
+/**
+ * gateway.ts — host-side HTTP gateway exposing the `interpreters` config to
+ * the browser through a self-hosted `/interpreters/api` route.
+ *
+ * The DSH typertGateway `/api` RPC dispatch was the original channel
+ * (TypertRemoteService + @Remote), but the host's SRC discovery
+ * (ctx.reflect.props enumeration) is not claiming plugin-owned service
+ * endpoints on the current dsh snapshot. The self-hosted HTTP route
+ * mirrors the better-sidebar pattern: `ctx.webServer.register` claims a
+ * prefix route, the handler reads/writes the settings seam in-process
+ * (no wire-layer allowlist gate), and the browser reaches it through
+ * `fetch('/interpreters/api/<method>')`.
+ *
+ * Route shape:
+ *   POST /interpreters/api/get  → { ok: true, value: { config: ResolvedConfig } }
+ *   POST /interpreters/api/set  body: { patch: Partial<Config> }
+ *                                → { ok: true, value: { config: ResolvedConfig } }
+ * Errors carry { ok: false, error: { code, message } }.
+ *
+ * @module dsh-interpreters/gateway
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Settings } from '@deepseek-ai/dsh-settings';
+import { type Config as ConfigType, type ResolvedConfig } from './config.js';
+import { type InterpretersSettingsBridge } from './settings.js';
+/** Wire view returned by both `get` and `set`: the fully-resolved config. */
+export interface InterpretersConfigView {
+    config: ResolvedConfig;
+}
+/** Patch shape the `set` endpoint accepts (every field optional, null = clear). */
+export type InterpretersConfigPatch = Partial<ConfigType>;
+/**
+ * Register the `/interpreters/api` HTTP route on the host's web server.
+ *
+ * The route reads/writes the `interpreters` settings namespace in-process
+ * through the bridge + `ctx.settings`. The settings service is optional:
+ * when absent, `get` degrades to the entry source and `set` returns a
+ * clear error.
+ * @param ctx - host context carrying `webServer`.
+ * @param bridge - the settings bridge the route reads through.
+ */
+export declare function registerHttpGateway(ctx: Context, bridge: InterpretersSettingsBridge): void;
+/**
+ * Handle the `set` method: validate the patch, write the user layer, return
+ * the new resolved config.
+ * @param body - the parsed JSON body from the request.
+ * @param settings - the live settings service (undefined when unavailable).
+ * @param bridge - the settings bridge for reading the source.
+ * @returns the new resolved config view.
+ * @throws when the settings service is unavailable.
+ */
+export declare function handleSet(body: unknown, settings: Settings | undefined, bridge: InterpretersSettingsBridge): Promise<InterpretersConfigView>;
+/**
+ * Extract and validate the patch from the request body.
+ *
+ * JSON wire boundary: null = "delete" (filtered), undefined never crosses
+ * JSON. Unknown keys are dropped (the settings service is non-strict and
+ * would otherwise store them). Light type guards constrain paths to
+ * strings and timeout to a finite number.
+ * @param body - the parsed JSON body.
+ * @returns the normalized patch (only known, well-typed keys).
+ */
+export declare function extractPatch(body: unknown): Record<string, unknown>;