@tomradex/plugin-sdk 0.2.0 → 0.2.16

package/README.md

@@ -60,4 +60,4 @@ export default definePlugin({
 }
 ```
 
-Declare what your code does beyond the SDK — the hosts it talks to, whether it touches the disk, whether it starts programs. The store's review compares it with the code. Community lists open-source plugins only, built from your public GitHub repository and reviewed before they are listed.
+Declare what your code does beyond the SDK — the hosts it talks to, whether it touches the disk, whether it starts programs. Whoever installs it sees it beside what the analyzer finds in the code. Community lists open-source plugins only, published from your public GitHub repository; nobody reviews them, so say plainly what yours does.

package/dist/cli-hooks.d.ts

@@ -0,0 +1,8 @@
+/** SDK 0.2.15: what a CLI agent's hook says happened, in one set of names whichever agent sent it. */
+export type CliHookEvent = "session-start" | "prompt" | "pre-tool" | "post-tool" | "stop" | "session-end";
+export declare const CLI_HOOK_EVENTS: readonly CliHookEvent[];
+export declare const CLI_HOOK_COVERAGE: Readonly<Record<CliHookEvent, {
+    answers: readonly string[];
+    sees: readonly string[];
+}>>;
+//# sourceMappingURL=cli-hooks.d.ts.map

package/dist/cli-hooks.js

@@ -0,0 +1,27 @@
+export const CLI_HOOK_EVENTS = ["session-start", "prompt", "pre-tool", "post-tool", "stop", "session-end"];
+/** The agents whose hooks reach Tomrade at all: in sessions it starts, or in repositories it connects. */
+const REPORTING = ["claude-code", "workbuddy", "dsh", "pi", "codex", "cursor", "opencode", "hermes"];
+const ANSWERS = {
+    "session-start": ["claude-code", "workbuddy", "dsh"],
+    prompt: ["claude-code", "workbuddy", "dsh"],
+    "pre-tool": ["claude-code", "workbuddy", "dsh", "pi"],
+    "post-tool": ["claude-code", "workbuddy", "dsh", "pi"],
+    stop: ["claude-code", "workbuddy", "dsh"],
+    "session-end": []
+};
+/**
+ * Which agents a CLI hook reaches. `answers`: in a session Tomrade started, the
+ * agent acts on the answer. `sees`: the hook hears the event — a connected
+ * repository's, or one the agent cannot be answered on — and its answer goes
+ * nowhere. Gemini CLI and Antigravity report no hooks at all.
+ */
+const reach = (event) => ({ answers: ANSWERS[event], sees: REPORTING.filter((agent) => !ANSWERS[event].includes(agent)) });
+export const CLI_HOOK_COVERAGE = {
+    "session-start": reach("session-start"),
+    prompt: reach("prompt"),
+    "pre-tool": reach("pre-tool"),
+    "post-tool": reach("post-tool"),
+    stop: reach("stop"),
+    "session-end": reach("session-end")
+};
+//# sourceMappingURL=cli-hooks.js.map

package/dist/contract.d.ts

@@ -1,4 +1,8 @@
 import type { z } from "zod";
+import type { ImApi } from "./im.js";
+import type { TerminalsApi } from "./terminals.js";
+import type { WebSearchApi } from "./web-search.js";
+import type { ModelsApi } from "./models.js";
 import type { Author, Board, CreateItemInput, FieldDef, FieldOption, FieldType, FilterClause, Item, ListItemsFilter, OplogEntity, OplogEntry, OplogOp, Patch, Project, SortKey, View } from "@tomradex/domain";
 /**
  * The plugin contract. Everything a plugin reaches returns a Promise, and every
@@ -7,8 +11,24 @@ import type { Author, Board, CreateItemInput, FieldDef, FieldOption, FieldType,
  * plain data — never a live object of the host's.
  */
 export type Disposer = () => void;
+/** A language the app may be speaking: a BCP 47 tag such as "en", "zh", "zh-Hant" or one a language pack adds ("pt-BR"). SDK 0.2.8 widened it from "en" | "zh". */
+export type Locale = string;
+/** Text in the app's language: a plain string, or one per language tag picked each time it is shown (English is the fallback). */
+export type Localized = string | ({
+    en: string;
+} & Partial<Record<Locale, string>>);
+/** A settings section's text in one language; fields are keyed by schema property. */
+export interface SectionWords {
+    title?: string;
+    description?: string;
+    fields?: Record<string, {
+        title?: string;
+        description?: string;
+        options?: Record<string, string>;
+    }>;
+}
 /** The services a plugin names in `inject` (required) or `optional`. */
-export type ServiceName = "items" | "fields" | "boards" | "views" | "projects" | "db" | "settings" | "tools" | "contributions" | "agent" | "surfaces" | "oplog";
+export type ServiceName = "items" | "fields" | "boards" | "views" | "projects" | "db" | "settings" | "tools" | "contributions" | "agent" | "surfaces" | "alerts" | "oplog" | "im" | "webSearch" | "terminals" | "models";
 export interface Logger {
     debug(...args: unknown[]): void;
     info(...args: unknown[]): void;
@@ -37,6 +57,30 @@ export interface ItemsApi {
     addRelation(projectId: string, id: string, blockedId: string): Promise<void>;
     removeRelation(projectId: string, id: string, blockedId: string): Promise<void>;
     labels(projectId: string): Promise<string[]>;
+    /**
+     * SDK 0.2.12: a policy over every write before it lands — items, and the workstream and view
+     * writes that take the same path — whoever writes. Throw to refuse it. It is asked inside the
+     * write's transaction, so it must answer at once: a check that returns a Promise is not waited
+     * for, and the write goes on.
+     */
+    gate(check: (write: PendingWrite) => void): Promise<Disposer>;
+}
+/** SDK 0.2.12: a write about to land, as a write gate sees it. A copy: changing it changes nothing. */
+export interface PendingWrite<T = unknown> {
+    projectId: string;
+    entity: OplogEntity;
+    op: OplogOp;
+    id: string;
+    by: Author;
+    /** The extension making the write, when one is. */
+    via: string | null;
+    runId: string | null;
+    /** The version the writer read, when it asserts one. */
+    baseVersion: number | null;
+    before: T | null;
+    after: T | null;
+    /** For an update: only the fields the writer asked to change. */
+    patch: Record<string, unknown> | null;
 }
 export interface FieldsApi {
     list(projectId: string): Promise<FieldDef[]>;
@@ -82,17 +126,21 @@ export interface TableSpec {
         via: string;
         table: string;
     };
-    /** Exported tables travel in the project's folder; `false` keeps them on this machine. */
+    /**
+     * Exported tables travel in the project's folder; `false` keeps them on this machine.
+     * `private` rows (conversations, say) never travel to a remote known to be public.
+     */
     export: {
         order: string;
         appendOnly?: boolean;
         always?: boolean;
+        private?: boolean;
     } | false;
 }
 /**
  * Plain SQL against the caches. The namespace is the plugin's own: tables are
  * `plugin_<namespace>_*`. Reads of the app's tables are allowed; writing them
- * goes around history and undo, and review says so.
+ * goes around history and undo, and the install dialog says so.
  */
 export interface DbApi {
     migrate(steps: {
@@ -122,14 +170,23 @@ export interface SettingsSectionSpec<T> {
     id?: string;
     title: string;
     description?: string;
+    /** Drawn from its JSON Schema; a field with `.meta({ advanced: true })` is folded under Advanced. */
     schema: z.ZodType<T>;
     defaults: T;
     scope?: "machine" | "user";
+    /** What agents may do with it through get_settings / update_settings. Defaults to read; a section holding a password is none. */
+    agent?: "write" | "read" | "none";
+    /** The card in other languages; `title`, `description` and the schema's own labels are the English. */
+    words?: Partial<Record<Locale, SectionWords>>;
 }
 export interface SettingsApi {
     register<T>(section: SettingsSectionSpec<T>): Promise<void>;
     get<T = unknown>(id?: string): Promise<T>;
     set<T = unknown>(value: T, id?: string): Promise<void>;
+    /** Opens the app's Settings on this plugin's section, bringing the window forward — for a click outside the window. */
+    show(id?: string): Promise<void>;
+    /** The app's language now. It is a setting: `settings.changed` fires when the person switches it. */
+    locale(): Promise<Locale>;
 }
 export interface ToolInvocation {
     projectId?: string;
@@ -143,6 +200,8 @@ export interface ToolSpec<S extends z.ZodObject = z.ZodObject> {
     title: string;
     description: string;
     input: S;
+    /** A kit few conversations need: the tool is left out of each request until the model loads the kit. Named like the tool. */
+    kit?: string;
     execute(args: z.output<S>, invocation: ToolInvocation): unknown | Promise<unknown>;
 }
 export interface ToolCallInfo {
@@ -154,6 +213,8 @@ export interface ToolCallInfo {
 }
 export interface ToolsApi {
     register<S extends z.ZodObject>(tool: ToolSpec<S>): Promise<Disposer>;
+    /** What a kit is for, in a few words the model reads before it loads the kit ("a focus timer"). */
+    kit(id: string, purpose: string): Promise<Disposer>;
     list(): Promise<{
         name: string;
         title: string;
@@ -163,9 +224,18 @@ export interface ToolsApi {
     call(name: string, args: unknown, opts?: {
         projectId?: string;
     }): Promise<unknown>;
-    /** A policy over every tool call: throw to refuse it. */
-    gate(check: (call: ToolCallInfo) => void | Promise<void>): Promise<Disposer>;
+    /**
+     * A policy over every tool call: throw to refuse it. SDK 0.2.12: or answer `{ args }` to go on with
+     * other arguments (checked against the tool's input again), or `{ result }` to answer in the tool's place.
+     */
+    gate(check: (call: ToolCallInfo) => ToolGateAnswer | void | Promise<ToolGateAnswer | void>): Promise<Disposer>;
 }
+/** SDK 0.2.12: what a tool gate may answer besides letting the call through unchanged. `result` wins over `args`. */
+export type ToolGateAnswer = {
+    args: unknown;
+} | {
+    result: unknown;
+};
 export type BadgeTone = "faint" | "neutral" | "strong";
 export interface Badge {
     id: string;
@@ -189,6 +259,15 @@ export interface SectionRow {
     href?: string;
     command?: string;
 }
+export interface SidebarRow {
+    id: string;
+    label: string;
+    icon?: string;
+    detail?: string;
+    count?: number | string;
+    command?: string;
+    href?: string;
+}
 export interface GraphEdge {
     from: string;
     to: string;
@@ -200,8 +279,8 @@ type Maybe<T> = T | Promise<T>;
 export interface ContributionsApi {
     command(def: {
         id: string;
-        title: string;
-        group?: string;
+        title: Localized;
+        group?: Localized;
         shortcut?: string;
         run(scope: CommandScope): Maybe<{
             toast?: string;
@@ -213,15 +292,36 @@ export interface ContributionsApi {
             projectId: string;
         }): Maybe<Record<string, Badge[]>>;
     }): Promise<Disposer>;
+    /**
+     * A status bar item. `command` (in the plugin's namespace) runs on click, or `menu` lists actions the click
+     * opens instead; `until` returns an epoch ms the renderer counts down to after the text, without polling.
+     * Everything is re-read when `refresh()` is called.
+     */
     statusItem(def: {
         id: string;
         text(scope: {
             projectId?: string;
         }): Maybe<string | null>;
+        title?: Localized;
+        icon?: string;
+        align?: "start" | "end";
+        command?: string;
+        until?(scope: {
+            projectId?: string;
+        }): Maybe<number | null>;
+        menu?(scope: {
+            projectId?: string;
+        }): Maybe<{
+            title: string;
+            command: string;
+            icon?: string;
+        }[] | null>;
     }): Promise<Disposer>;
+    /** Every window re-reads this plugin's contributions — for state that changed outside a command run. */
+    refresh(): Promise<void>;
     section(def: {
         id: string;
-        title: string;
+        title: Localized;
         render(item: Item): Maybe<{
             rows?: SectionRow[];
             text?: string;
@@ -236,6 +336,16 @@ export interface ContributionsApi {
             projectId: string;
         }): Maybe<GraphEdge[]>;
     }): Promise<Disposer>;
+    /** A module in the project sidebar. Without `rows` it is a single door; rows returning null hide it in that project. */
+    sidebarModule(def: {
+        id: string;
+        title: Localized;
+        icon?: string;
+        command?: string;
+        rows?(scope: {
+            projectId: string;
+        }): Maybe<SidebarRow[] | null>;
+    }): Promise<Disposer>;
 }
 export interface PlaybookSpec {
     /** Must start with the namespace. */
@@ -246,26 +356,173 @@ export interface PlaybookSpec {
     body: string;
     tools?: string[];
 }
+/** SDK 0.2.14: one block of a model message, as an in-app conversation sends it. */
+export type ModelContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "media";
+    media: {
+        mime: string;
+        base64: string;
+        name: string;
+    };
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+    args: unknown;
+} | {
+    type: "tool_result";
+    id: string;
+    content: string;
+    isError?: boolean;
+} | {
+    type: "native";
+    provider: string;
+    data: unknown;
+};
+export interface ModelMessage {
+    role: "user" | "assistant";
+    content: ModelContent[];
+}
+/** A tool as the model is offered it; `inputSchema` is JSON Schema. */
+export interface ModelTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** Which turn, step and model profile a request belongs to. */
+export interface TurnInfo {
+    runId: string;
+    threadId: string;
+    projectId: string;
+    purpose: string;
+    profile: string;
+    step: number;
+}
+/** SDK 0.2.14: one model request an in-app conversation is about to send. A copy: what the hook answers is what changes. */
+export interface ModelRequest {
+    system: string;
+    tools: ModelTool[];
+    messages: ModelMessage[];
+    turn: TurnInfo;
+}
+export type ModelRequestChange = Partial<Pick<ModelRequest, "system" | "tools" | "messages">>;
+export interface ModelRequestFailure {
+    /** What the provider or the network said. */
+    message: string;
+    request: ModelRequest;
+    /** How many times this step was already sent again on a hook's answer. */
+    attempt: number;
+}
+/** Send the request again: changed, on another model profile (an id from the person's profiles), or both. */
+export interface ModelRetry {
+    request?: ModelRequestChange;
+    profile?: string;
+}
+export interface TurnEnding {
+    /** What the model said last. */
+    text: string;
+    turn: TurnInfo;
+    /** How many times this turn was already kept going. */
+    continued: number;
+}
+/**
+ * The agent's in-app conversations. The three hooks (SDK 0.2.14) reach the
+ * conversation Tomrade runs itself (`engine-loop`); CLI agents — Claude Code,
+ * Codex, dsh and the rest — run their own loop and send nothing through them.
+ */
 export interface AgentApi {
     playbook(spec: PlaybookSpec): Promise<Disposer>;
+    /** Before each model request: answer the parts to send instead, or nothing to leave it as it is. */
+    request(hook: (request: ModelRequest) => Maybe<ModelRequestChange | void>): Promise<Disposer>;
+    /** A model request failed: answer what to try instead, or nothing to let the failure stand. The first plugin to answer decides. */
+    requestError(hook: (failure: ModelRequestFailure) => Maybe<ModelRetry | void>): Promise<Disposer>;
+    /** A turn is about to end: answer `{ continue }` with a message to the model to keep it going. Bounded, so it cannot run forever. */
+    turnEnding(hook: (ending: TurnEnding) => Maybe<{
+        continue: string;
+    } | void>): Promise<Disposer>;
+    /**
+     * SDK 0.2.15: a hook in the CLI agents Tomrade works with — Claude Code, Codex, dsh and the rest. It
+     * hears their sessions and, in one Tomrade started, may answer: see `CLI_HOOK_COVERAGE` for which.
+     */
+    cliHook(spec: CliHookSpec): Promise<Disposer>;
+}
+export type { CliHookEvent } from "./cli-hooks.js";
+/** SDK 0.2.15: what a CLI agent's hook says happened, whichever agent sent it. */
+export interface CliHookCall {
+    event: import("./cli-hooks.js").CliHookEvent;
+    /** `claude-code`, `codex`, `dsh`, `pi`, `workbuddy`, `cursor`, `opencode`, `hermes`… */
+    agent: string;
+    /** Whether an answer reaches the agent: a session Tomrade started, by an agent that acts on this event. */
+    answerable: boolean;
+    projectId: string;
+    /** Tomrade's code session the hook belongs to. */
+    sessionId: string;
+    /** The ticket the session works, when it has one. */
+    ticket: string | null;
+    cwd: string | null;
+    tool?: {
+        name: string;
+        input: unknown;
+        output?: string;
+        error?: string;
+    };
+    /** What the model said last, at `stop`. */
+    text?: string;
+    /** The hook's own payload, as the agent sent it. */
+    raw: Record<string, unknown>;
+}
+/** Refuse the tool (`pre-tool`), add context for the model (`session-start`, `prompt`, `post-tool`), or keep the turn going (`stop`). */
+export interface CliHookAnswer {
+    deny?: string;
+    context?: string;
+    continue?: string;
+}
+export interface CliHookSpec {
+    /** The events it hears; all of them when left out. */
+    events?: import("./cli-hooks.js").CliHookEvent[];
+    /** A regular expression the tool's name must match, for `pre-tool` and `post-tool`. */
+    tools?: string;
+    /** The agents it hears; all of them when left out. */
+    agents?: string[];
+    handle(call: CliHookCall): Maybe<CliHookAnswer | void>;
 }
 export interface SurfaceSpec {
     id: string;
     title: string;
+    /**
+     * SDK 0.2.11: `"window"` is a working window — title bar, resizable, closable, in the Dock or
+     * taskbar, its bounds remembered — and needs `permissions.window`. The default `"widget"` is
+     * the fixed, frameless surface it always was. A window's title carries the plugin's own.
+     */
+    kind?: "widget" | "window";
+    /** SDK 0.2.11, windows only: how small the person may make it. */
+    minWidth?: number;
+    minHeight?: number;
     /** A document inside the plugin's package, relative to its root. Remote pages are refused. */
     document: string;
     width: number;
     height: number;
     transparent?: boolean;
     alwaysOnTop?: boolean;
+    /** Allow keyboard input; defaults to false for passive widgets. */
+    focusable?: boolean;
     clickThrough?: boolean;
+    /** First placed on top of an app element by name — `"sidebar-foot"`: just above the sidebar's Project settings. */
+    anchor?: string;
     initialState?: unknown;
     /** Messages the document sends; a person is driving, so writes made here are theirs. */
     onMessage?(message: unknown): Maybe<void>;
+    /** Once, when the window is gone — the person closed it, `close()` did, or the plugin unloaded. The handle's other calls then reject. */
+    onClose?(): Maybe<void>;
 }
 export interface SurfaceHandle {
     readonly id: string;
     setState(state: unknown): Promise<void>;
+    /** SDK 0.2.11: one message to the document's `tomradeSurface.onMessage`, for frequent small updates; `setState` replaces the whole state. */
+    post(message: unknown): Promise<void>;
     setPosition(x: number, y: number): Promise<void>;
     bounds(): Promise<{
         x: number;
@@ -284,6 +541,25 @@ export interface SurfaceHandle {
 export interface SurfacesApi {
     open(spec: SurfaceSpec): Promise<SurfaceHandle>;
 }
+/** A sound the machine offers: `system:<name>`. A file the person chose is played by its absolute path. */
+export interface AlertSound {
+    id: string;
+    title: string;
+}
+/** Alerts the system raises for the plugin. The plugin chooses when; it never reads the sound file itself. */
+export interface AlertsApi {
+    /** The system sounds on this machine, the system's own alert sound first. */
+    sounds(): Promise<AlertSound[]>;
+    /** Plays a system sound or an audio file once; volume runs 0–1. */
+    play(sound: string, opts?: {
+        volume?: number;
+    }): Promise<void>;
+    /** A silent system notification; clicking it brings Tomrade forward. */
+    notify(notice: {
+        title: string;
+        body?: string;
+    }): Promise<void>;
+}
 export interface OplogApi {
     recent(projectId: string, limit?: number): Promise<OplogEntry[]>;
     history(projectId: string, entity: OplogEntity, id: string, limit?: number): Promise<OplogEntry[]>;
@@ -325,8 +601,16 @@ export interface PluginContext {
     readonly tools: ToolsApi;
     readonly contributions: ContributionsApi;
     readonly agent: AgentApi;
+    readonly im: ImApi;
     readonly surfaces: SurfacesApi;
+    readonly alerts: AlertsApi;
     readonly oplog: OplogApi;
+    /** SDK 0.2.9: answers the agent's web search, as the app's own providers do. */
+    readonly webSearch: WebSearchApi;
+    /** SDK 0.2.10: live terminals of the herdr panes code sessions run in. */
+    readonly terminals: TerminalsApi;
+    /** SDK 0.2.16: model providers, as the app's own are. */
+    readonly models: ModelsApi;
     on<K extends keyof Events>(event: K, listener: Events[K]): Disposer;
     /** Runs `fn` while an optional service is present; what it returns is disposed when the service goes. */
     when(name: ServiceName, fn: (ctx: PluginContext) => Maybe<Disposer | void>): Disposer;
@@ -337,5 +621,4 @@ export interface PluginContext {
     /** A timer cleared with the plugin. */
     interval(fn: () => Maybe<void>, ms: number): Disposer;
 }
-export {};
 //# sourceMappingURL=contract.d.ts.map

package/dist/exports.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The contract each value the SDK exports first shipped in. A plugin imports
+ * the SDK from the Tomrade it runs in, not from its own bundle, so a name the
+ * oldest Tomrade its `engines.sdk` accepts does not have fails the plugin as it
+ * loads. A new export is listed here under the contract it ships in.
+ */
+export declare const SDK_EXPORTS: Readonly<Record<string, string>>;
+/** The oldest contract `range` accepts, up to this SDK's own; null when it accepts none of them. */
+export declare function lowestContract(range: string): string | null;
+//# sourceMappingURL=exports.d.ts.map

package/dist/exports.js

@@ -0,0 +1,73 @@
+import { SDK_CONTRACT } from "./manifest.js";
+import { compareVersions, parseVersion, satisfies } from "./semver.js";
+/**
+ * The contract each value the SDK exports first shipped in. A plugin imports
+ * the SDK from the Tomrade it runs in, not from its own bundle, so a name the
+ * oldest Tomrade its `engines.sdk` accepts does not have fails the plugin as it
+ * loads. A new export is listed here under the contract it ships in.
+ */
+export const SDK_EXPORTS = {
+    ContributesSchema: "0.2.0",
+    MANIFEST_FILE: "0.2.0",
+    ManifestSchema: "0.2.0",
+    NAMESPACE: "0.2.0",
+    OFFICIAL_PUBLISHER: "0.2.0",
+    OSI_LICENSES: "0.2.0",
+    PLUGIN_ID: "0.2.0",
+    PermissionsSchema: "0.2.0",
+    RESERVED_NAMESPACES: "0.2.0",
+    SDK_CONTRACT: "0.2.0",
+    SDK_PLUGIN: "0.2.0",
+    ToolInputError: "0.2.0",
+    assertOwned: "0.2.0",
+    compareVersions: "0.2.0",
+    definePlugin: "0.2.0",
+    defineTool: "0.2.0",
+    isOpenSource: "0.2.0",
+    isSdkPlugin: "0.2.0",
+    isVersion: "0.2.0",
+    nameOf: "0.2.0",
+    namespaceOf: "0.2.0",
+    ownsId: "0.2.0",
+    parseManifest: "0.2.0",
+    parseVersion: "0.2.0",
+    publisherOf: "0.2.0",
+    requireProjectId: "0.2.0",
+    riskOf: "0.2.0",
+    satisfies: "0.2.0",
+    ImDeliveryError: "0.2.1",
+    IM_CAPABILITIES_V2: "0.2.5",
+    IM_MARKDOWN_DIALECTS: "0.2.5",
+    ImCapabilitiesSchema: "0.2.5",
+    resolveImCapabilities: "0.2.5",
+    splitImText: "0.2.5",
+    toImDialect: "0.2.5",
+    isRange: "0.2.7",
+    LANGUAGE_PACK_LIMITS: "0.2.8",
+    LanguageEntrySchema: "0.2.8",
+    LanguagePackFileSchema: "0.2.8",
+    languageCoverage: "0.2.8",
+    parseLanguagePack: "0.2.8",
+    slotsOf: "0.2.8",
+    SDK_EXPORTS: "0.2.9",
+    lowestContract: "0.2.9",
+    pickLanguage: "0.2.9",
+    wordsFor: "0.2.9",
+    RowSchema: "0.2.13",
+    CLI_HOOK_COVERAGE: "0.2.15",
+    CLI_HOOK_EVENTS: "0.2.15"
+};
+/** The oldest contract `range` accepts, up to this SDK's own; null when it accepts none of them. */
+export function lowestContract(range) {
+    const known = [...Object.values(SDK_EXPORTS), SDK_CONTRACT];
+    // Every patch of each minor the SDK has shipped, since a contract that added no export is still one a Tomrade may run.
+    const lines = new Map();
+    for (const v of known) {
+        const p = parseVersion(v);
+        if (p)
+            lines.set(`${p[0]}.${p[1]}`, Math.max(lines.get(`${p[0]}.${p[1]}`) ?? 0, p[2]));
+    }
+    const candidates = [...lines].flatMap(([line, last]) => Array.from({ length: last + 1 }, (_, patch) => `${line}.${patch}`)).sort(compareVersions);
+    return candidates.find((v) => compareVersions(v, SDK_CONTRACT) <= 0 && satisfies(v, range)) ?? null;
+}
+//# sourceMappingURL=exports.js.map

package/dist/im-markdown.d.ts

@@ -0,0 +1,10 @@
+import type { ImMarkdownDialect } from "./im.js";
+/** Converts the common layer's Markdown into an adapter's dialect. */
+export declare function toImDialect(markdown: string, dialect: ImMarkdownDialect): string;
+/**
+ * Splits Markdown into messages that each fit `max` once converted, breaking
+ * between lines. A code block stays whole when it fits a message; a longer one
+ * is closed and reopened with its language rather than cut mid-fence.
+ */
+export declare function splitImText(markdown: string, max: number, dialect?: ImMarkdownDialect): string[];
+//# sourceMappingURL=im-markdown.d.ts.map