@tomradex/plugin-sdk 0.0.0-stage → 0.2.16

package/dist/im.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export const IM_MARKDOWN_DIALECTS = ["plain", "markdown", "slack", "telegram-html", "discord", "lark", "dingtalk", "wecom"];
+/** The capability fields only SDK 0.2.5 understands; declaring one needs `engines.sdk` of at least that. */
+export const IM_CAPABILITIES_V2 = ["threads", "reactions", "typing", "stream", "select", "multiSelect", "textInput", "cards", "cardUpdate", "nativeCommands", "ephemeral", "markdown", "rateLimit"];
+export const ImCapabilitiesSchema = z.object({
+    edit: z.boolean(),
+    buttons: z.boolean(),
+    inboundFiles: z.boolean(),
+    outboundFiles: z.boolean(),
+    maxTextLength: z.number().int().min(128),
+    maxFileBytes: z.number().int().min(0),
+    threads: z.boolean().optional(),
+    reactions: z.boolean().optional(),
+    typing: z.boolean().optional(),
+    stream: z.enum(["native", "edit", "none"]).optional(),
+    select: z.boolean().optional(),
+    multiSelect: z.boolean().optional(),
+    textInput: z.boolean().optional(),
+    cards: z.boolean().optional(),
+    cardUpdate: z.boolean().optional(),
+    nativeCommands: z.boolean().optional(),
+    ephemeral: z.boolean().optional(),
+    markdown: z.enum(IM_MARKDOWN_DIALECTS).optional(),
+    rateLimit: z.object({ messages: z.number().int().min(1), windowMs: z.number().int().min(1) }).optional()
+});
+export function resolveImCapabilities(caps) {
+    const parsed = ImCapabilitiesSchema.parse(caps);
+    return {
+        ...parsed,
+        threads: parsed.threads ?? false,
+        reactions: parsed.reactions ?? false,
+        typing: parsed.typing ?? false,
+        stream: parsed.stream ?? "none",
+        select: parsed.select ?? false,
+        multiSelect: parsed.multiSelect ?? false,
+        textInput: parsed.textInput ?? false,
+        cards: parsed.cards ?? false,
+        cardUpdate: parsed.cardUpdate ?? parsed.edit,
+        nativeCommands: parsed.nativeCommands ?? false,
+        ephemeral: parsed.ephemeral ?? false,
+        markdown: parsed.markdown ?? "markdown"
+    };
+}
+/** Only a known-unsent operation is safe to retry; unknown failures remain uncertain. */
+export class ImDeliveryError extends Error {
+    disposition;
+    retryAfterMs;
+    constructor(message, disposition, retryAfterMs) {
+        super(message);
+        this.disposition = disposition;
+        this.retryAfterMs = retryAfterMs;
+        this.name = "ImDeliveryError";
+    }
+}
+//# sourceMappingURL=im.js.map

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./contract.js";
+export { SDK_PLUGIN, ToolInputError, definePlugin, defineTool, isSdkPlugin, requireProjectId, type PluginSpec, type SdkPlugin } from "./define.js";
+export * from "./manifest.js";
+export * from "./language.js";
+export * from "./exports.js";
+export { compareVersions, isRange, isVersion, parseVersion, satisfies } from "./semver.js";
+export type { Author, Board, CreateItemInput, FieldDef, FieldOption, FieldType, FieldValue, FilterClause, Item, ItemKind, ItemStatus, ListItemsFilter, OplogEntity, OplogEntry, OplogOp, Patch, Priority, Project, SortKey, View, WorkType } from "@tomradex/domain";
+export * from "./im.js";
+export * from "./web-search.js";
+export * from "./models.js";
+export * from "./terminals.js";
+export { CLI_HOOK_COVERAGE, CLI_HOOK_EVENTS } from "./cli-hooks.js";
+export * from "./im-markdown.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from "./contract.js";
+export { SDK_PLUGIN, ToolInputError, definePlugin, defineTool, isSdkPlugin, requireProjectId } from "./define.js";
+export * from "./manifest.js";
+export * from "./language.js";
+export * from "./exports.js";
+export { compareVersions, isRange, isVersion, parseVersion, satisfies } from "./semver.js";
+export * from "./im.js";
+export * from "./web-search.js";
+export * from "./models.js";
+export * from "./terminals.js";
+export { CLI_HOOK_COVERAGE, CLI_HOOK_EVENTS } from "./cli-hooks.js";
+export * from "./im-markdown.js";
+//# sourceMappingURL=index.js.map

package/dist/language.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { type Dictionaries } from "@tomradex/domain";
+import type { Locale } from "./contract.js";
+export { languageCoverage, pickLanguage, slotsOf, type Dictionaries, type LanguageCoverage } from "@tomradex/domain";
+/**
+ * A plugin's own words in the app's language (`ctx.settings.locale()`): the
+ * closest language it has, picked as Tomrade picks its own (zh-TW finds
+ * zh-Hant, never zh), and English when it has none of that language.
+ */
+export declare function wordsFor<T>(locale: Locale, words: {
+    en: T;
+} & Partial<Record<Locale, T>>): T;
+/**
+ * A language pack: data only. The manifest names each language a plugin adds
+ * and the JSON file holding its words; nothing in it runs, and every string
+ * is shown as plain text in place of the English it translates.
+ */
+/** The largest pack file Tomrade reads, and the longest single template. */
+export declare const LANGUAGE_PACK_LIMITS: {
+    fileBytes: number;
+    templateChars: number;
+    languages: number;
+};
+export declare const LanguageEntrySchema: z.ZodObject<{
+    tag: z.ZodString;
+    name: z.ZodString;
+    file: z.ZodString;
+}, z.core.$strip>;
+export type LanguageEntry = z.output<typeof LanguageEntrySchema>;
+/**
+ * What a pack file holds: `ui` translates the interface's dictionaries,
+ * `backend` the backend's books, each `namespace → key → template`, keyed as
+ * English is. A template names its values as `{{slot}}`, exactly the slots
+ * English's does; an entry that does not, or a key English lacks, reads English.
+ */
+export declare const LanguagePackFileSchema: z.ZodObject<{
+    ui: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    backend: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strict>;
+export interface LanguagePack {
+    tag: string;
+    name: string;
+    ui: Dictionaries;
+    backend: Dictionaries;
+}
+/** A pack file's text checked against the format; throws with the first problem. */
+export declare function parseLanguagePack(entry: LanguageEntry, text: string): LanguagePack;
+//# sourceMappingURL=language.d.ts.map

package/dist/language.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { canonicalTag, pickLanguage } from "@tomradex/domain";
+export { languageCoverage, pickLanguage, slotsOf } from "@tomradex/domain";
+/**
+ * A plugin's own words in the app's language (`ctx.settings.locale()`): the
+ * closest language it has, picked as Tomrade picks its own (zh-TW finds
+ * zh-Hant, never zh), and English when it has none of that language.
+ */
+export function wordsFor(locale, words) {
+    return words[pickLanguage(locale, Object.keys(words)) ?? "en"] ?? words.en;
+}
+/**
+ * A language pack: data only. The manifest names each language a plugin adds
+ * and the JSON file holding its words; nothing in it runs, and every string
+ * is shown as plain text in place of the English it translates.
+ */
+/** The largest pack file Tomrade reads, and the longest single template. */
+export const LANGUAGE_PACK_LIMITS = { fileBytes: 2 * 1024 * 1024, templateChars: 4_000, languages: 16 };
+export const LanguageEntrySchema = z.object({
+    /** A BCP 47 tag: "pt-BR", "ko", "zh-Hant". */
+    tag: z
+        .string()
+        .refine((t) => canonicalTag(t) === t, "a canonical BCP 47 language tag such as \"pt-BR\" or \"ko\"")
+        .refine((t) => t !== "en", "English is what every pack translates; it cannot be replaced"),
+    /** The language's name in itself, as Settings → Language lists it: "Português (Brasil)". */
+    name: z.string().trim().min(1).max(60),
+    /** The pack's words, a JSON file inside the plugin: "languages/pt-BR.json". */
+    file: z
+        .string()
+        .regex(/^[A-Za-z0-9_-][A-Za-z0-9._/-]*\.json$/, "a relative path to a .json file inside the plugin")
+        .refine((f) => !f.split("/").includes(".."), "the file must stay inside the plugin")
+});
+const Words = z.record(z.string().min(1), z.record(z.string().min(1), z.string().max(LANGUAGE_PACK_LIMITS.templateChars)));
+/**
+ * What a pack file holds: `ui` translates the interface's dictionaries,
+ * `backend` the backend's books, each `namespace → key → template`, keyed as
+ * English is. A template names its values as `{{slot}}`, exactly the slots
+ * English's does; an entry that does not, or a key English lacks, reads English.
+ */
+export const LanguagePackFileSchema = z
+    .object({
+    ui: Words.default({}),
+    backend: Words.default({})
+})
+    .strict();
+/** A pack file's text checked against the format; throws with the first problem. */
+export function parseLanguagePack(entry, text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`${entry.file} is not JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const parsed = LanguagePackFileSchema.safeParse(raw);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        throw new Error(`${entry.file} ${issue.path.join(".") || "(root)"}: ${issue.message}`);
+    }
+    return { tag: entry.tag, name: entry.name, ui: parsed.data.ui, backend: parsed.data.backend };
+}
+//# sourceMappingURL=language.js.map

package/dist/manifest.d.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+/** The contract this SDK describes. A plugin's `engines.sdk` range is checked against the host's. */
+export declare const SDK_CONTRACT = "0.2.16";
+export declare const PLUGIN_ID: RegExp;
+export declare const NAMESPACE: RegExp;
+/** The app's own names, and the official publisher's. */
+export declare const RESERVED_NAMESPACES: Set<string>;
+export declare const OFFICIAL_PUBLISHER = "tomrade";
+export declare const PermissionsSchema: z.ZodDefault<z.ZodObject<{
+    network: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    fs: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        project: "project";
+        any: "any";
+        plugin: "plugin";
+    }>>;
+    exec: z.ZodDefault<z.ZodBoolean>;
+    window: z.ZodDefault<z.ZodBoolean>;
+    why: z.ZodOptional<z.ZodObject<{
+        network: z.ZodOptional<z.ZodString>;
+        fs: z.ZodOptional<z.ZodString>;
+        exec: z.ZodOptional<z.ZodString>;
+        window: z.ZodOptional<z.ZodString>;
+        full: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare const ContributesSchema: z.ZodObject<{
+    tools: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    commands: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    badges: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    statusItems: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    sections: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    graphs: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    sidebarModules: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    playbooks: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    settings: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    surfaces: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    tables: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    imAdapters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    webSearchProviders: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    agentHooks: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    modelProviders: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+/**
+ * One row a full-mode plugin lays over Tomrade's composition, merged by id like a
+ * `tomrade.patch.yml` row: an app row's id switches it off, replaces its plugin or
+ * changes its config; a new id (carrying the namespace) adds a row. A relative
+ * `name` is a file inside the package.
+ */
+export declare const RowSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodUnknown>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ManifestRow = z.output<typeof RowSchema>;
+export declare const ManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    namespace: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    license: z.ZodString;
+    repository: z.ZodOptional<z.ZodURL>;
+    homepage: z.ZodOptional<z.ZodURL>;
+    author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strip>>;
+    engines: z.ZodObject<{
+        sdk: z.ZodString;
+        tomrade: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    context: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        sdk: "sdk";
+    }>>;
+    rows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        config: z.ZodOptional<z.ZodUnknown>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    main: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    icon: z.ZodOptional<z.ZodString>;
+    languages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        tag: z.ZodString;
+        name: z.ZodString;
+        file: z.ZodString;
+    }, z.core.$strip>>>;
+    permissions: z.ZodDefault<z.ZodObject<{
+        network: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        fs: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            project: "project";
+            any: "any";
+            plugin: "plugin";
+        }>>;
+        exec: z.ZodDefault<z.ZodBoolean>;
+        window: z.ZodDefault<z.ZodBoolean>;
+        why: z.ZodOptional<z.ZodObject<{
+            network: z.ZodOptional<z.ZodString>;
+            fs: z.ZodOptional<z.ZodString>;
+            exec: z.ZodOptional<z.ZodString>;
+            window: z.ZodOptional<z.ZodString>;
+            full: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    inject: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        items: "items";
+        fields: "fields";
+        boards: "boards";
+        views: "views";
+        projects: "projects";
+        db: "db";
+        settings: "settings";
+        tools: "tools";
+        contributions: "contributions";
+        agent: "agent";
+        surfaces: "surfaces";
+        alerts: "alerts";
+        oplog: "oplog";
+        im: "im";
+        webSearch: "webSearch";
+        terminals: "terminals";
+        models: "models";
+    }>>>;
+    optional: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        items: "items";
+        fields: "fields";
+        boards: "boards";
+        views: "views";
+        projects: "projects";
+        db: "db";
+        settings: "settings";
+        tools: "tools";
+        contributions: "contributions";
+        agent: "agent";
+        surfaces: "surfaces";
+        alerts: "alerts";
+        oplog: "oplog";
+        im: "im";
+        webSearch: "webSearch";
+        terminals: "terminals";
+        models: "models";
+    }>>>;
+    contributes: z.ZodDefault<z.ZodObject<{
+        tools: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        commands: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        badges: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        statusItems: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        sections: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        graphs: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        sidebarModules: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        playbooks: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        settings: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        surfaces: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        tables: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        imAdapters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        webSearchProviders: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        agentHooks: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+        modelProviders: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+    authoredBy: z.ZodDefault<z.ZodEnum<{
+        agent: "agent";
+        human: "human";
+        mixed: "mixed";
+    }>>;
+    forkOf: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Manifest = z.output<typeof ManifestSchema>;
+export type ManifestInput = z.input<typeof ManifestSchema>;
+export type Permissions = z.output<typeof PermissionsSchema>;
+export declare const MANIFEST_FILE = "tomrade-plugin.json";
+export declare function parseManifest(raw: unknown): Manifest;
+export declare const publisherOf: (id: string) => string;
+export declare const nameOf: (id: string) => string;
+/** The prefix every id the plugin registers carries, and the name of its tables. */
+export declare const namespaceOf: (manifest: Pick<Manifest, "id" | "namespace">) => string;
+export declare const ownsId: (namespace: string, id: string) => boolean;
+export declare function assertOwned(namespace: string, id: string, kind: string): void;
+export type RiskLevel = "low" | "elevated" | "high";
+export interface Risk {
+    level: RiskLevel;
+    /** Stable keys the UI words: `full`, `rows`, `exec`, `fs-any`, `network-any`, `network`, `fs-project`, `db`, `models`, `window`. */
+    reasons: string[];
+}
+/**
+ * High risk is labelled, not refused: running with Tomrade's whole context or
+ * changing its own rows, running programs, reading anywhere on disk, or talking
+ * to any host. Elevated is what a person should still see.
+ */
+export declare function riskOf(manifest: Pick<Manifest, "permissions" | "inject" | "optional"> & Partial<Pick<Manifest, "context" | "rows">>): Risk;
+/** OSI-approved licenses the store accepts without a second look. */
+export declare const OSI_LICENSES: Set<string>;
+export declare const isOpenSource: (license: string) => boolean;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { LANGUAGE_PACK_LIMITS, LanguageEntrySchema } from "./language.js";
+import { isRange, isVersion } from "./semver.js";
+/** The contract this SDK describes. A plugin's `engines.sdk` range is checked against the host's. */
+export const SDK_CONTRACT = "0.2.16";
+export const PLUGIN_ID = /^[a-z0-9][a-z0-9-]{0,38}\/[a-z0-9][a-z0-9-]{0,63}$/;
+export const NAMESPACE = /^[a-z][a-z0-9_]{1,31}$/;
+/** The app's own names, and the official publisher's. */
+export const RESERVED_NAMESPACES = new Set([
+    "agent", "alerts", "archify", "boards", "code_link", "contributions", "core", "db", "deps", "deps_graph", "fields", "files", "hub", "im", "ipc", "items",
+    "llm", "mcp", "oplog", "pet", "plugin", "plugins", "pomodoro", "projects", "repos", "settings", "storage", "surfaces", "system", "tomrade", "tools", "views", "write"
+]);
+export const OFFICIAL_PUBLISHER = "tomrade";
+const SERVICE = z.enum(["items", "fields", "boards", "views", "projects", "db", "settings", "tools", "contributions", "agent", "surfaces", "alerts", "oplog", "im", "webSearch", "terminals", "models"]);
+export const PermissionsSchema = z
+    .object({
+    /** Hosts the plugin talks to; `*` means any. */
+    network: z.array(z.string().min(1)).default([]),
+    /** `plugin`: its own data directory. `project`: the project folders. `any`: anywhere on disk. */
+    fs: z.enum(["none", "plugin", "project", "any"]).default("none"),
+    /** Starts other programs. */
+    exec: z.boolean().default(false),
+    /** SDK 0.2.11: opens working windows of its own (a surface of kind "window"), which take keys like any app window. */
+    window: z.boolean().default(false),
+    /** Why the plugin needs a wide permission, in a sentence a person installing it can judge. Official plugins must say. */
+    why: z.object({ network: z.string().min(1), fs: z.string().min(1), exec: z.string().min(1), window: z.string().min(1), full: z.string().min(1) }).partial().optional()
+})
+    .default({ network: [], fs: "none", exec: false, window: false });
+export const ContributesSchema = z
+    .object({
+    tools: z.array(z.string()).default([]),
+    commands: z.array(z.string()).default([]),
+    badges: z.array(z.string()).default([]),
+    statusItems: z.array(z.string()).default([]),
+    sections: z.array(z.string()).default([]),
+    graphs: z.array(z.string()).default([]),
+    sidebarModules: z.array(z.string()).default([]),
+    playbooks: z.array(z.string()).default([]),
+    settings: z.array(z.string()).default([]),
+    surfaces: z.array(z.string()).default([]),
+    tables: z.array(z.string()).default([]),
+    imAdapters: z.array(z.string()).default([]),
+    webSearchProviders: z.array(z.string()).default([]),
+    /** SDK 0.2.15: the CLI agent hook events it hears. */
+    agentHooks: z.array(z.string()).default([]),
+    /** SDK 0.2.16: the model providers it registers. */
+    modelProviders: z.array(z.string()).default([])
+})
+    .partial();
+/**
+ * One row a full-mode plugin lays over Tomrade's composition, merged by id like a
+ * `tomrade.patch.yml` row: an app row's id switches it off, replaces its plugin or
+ * changes its config; a new id (carrying the namespace) adds a row. A relative
+ * `name` is a file inside the package.
+ */
+export const RowSchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string().min(1).optional(),
+    title: z.string().min(1).optional(),
+    config: z.unknown().optional(),
+    disabled: z.boolean().optional()
+})
+    .refine((row) => row.name !== undefined || row.config !== undefined || row.disabled !== undefined, "a row changes something: name, config or disabled");
+export const ManifestSchema = z.object({
+    id: z.string().regex(PLUGIN_ID, "publisher/name, lowercase letters, digits and dashes"),
+    namespace: z.string().regex(NAMESPACE, "lowercase letters, digits and underscores, 2–32 long, starting with a letter").optional(),
+    version: z.string().refine(isVersion, "a semantic version such as 1.2.0"),
+    title: z.string().min(1).max(60),
+    description: z.string().max(500).default(""),
+    /** An SPDX identifier of an OSI-approved license. */
+    license: z.string().min(1),
+    repository: z.url().optional(),
+    homepage: z.url().optional(),
+    author: z.object({ name: z.string().min(1), url: z.url().optional() }).optional(),
+    engines: z.object({
+        sdk: z.string().refine(isRange, "a version range such as ^0.2.0"),
+        /** SDK 0.2.13: the Tomrade versions a full-mode plugin works with; it reaches internals the SDK range does not cover. */
+        tomrade: z.string().refine(isRange, "a version range such as >=0.13.0 <0.14.0").optional()
+    }),
+    /**
+     * SDK 0.2.13: what `main` receives. `"sdk"` is a `definePlugin` plugin behind the async facade;
+     * `"full"` is a plain cordis plugin given Tomrade's whole Context, as the app's own modules are.
+     */
+    context: z.enum(["sdk", "full"]).default("sdk"),
+    /** SDK 0.2.13, full mode only: rows laid over Tomrade's own, as `tomrade.patch.yml` rows are. */
+    rows: z.array(RowSchema).default([]),
+    /** The built code; `null` for a plugin that is data only, such as a language pack. */
+    main: z.string().nullable().default("dist/index.js"),
+    icon: z.string().optional(),
+    /** Languages the plugin adds, each a JSON file of words (SDK 0.2.8). */
+    languages: z.array(LanguageEntrySchema).max(LANGUAGE_PACK_LIMITS.languages).default([]),
+    permissions: PermissionsSchema,
+    /** Stamped by `tomrade-plugin build` from the exported plugin. */
+    inject: z.array(SERVICE).default([]),
+    optional: z.array(SERVICE).default([]),
+    contributes: ContributesSchema.default({}),
+    authoredBy: z.enum(["human", "agent", "mixed"]).default("human"),
+    /** A fork names what it came from; the store credits the original. */
+    forkOf: z.object({ id: z.string().regex(PLUGIN_ID), version: z.string() }).optional()
+});
+export const MANIFEST_FILE = "tomrade-plugin.json";
+export function parseManifest(raw) {
+    const manifest = ManifestSchema.parse(raw);
+    const ns = namespaceOf(manifest);
+    if (!NAMESPACE.test(ns))
+        throw new Error(`${manifest.id}: the name part does not make a valid namespace ("${ns}"); set "namespace" in ${MANIFEST_FILE}`);
+    if (RESERVED_NAMESPACES.has(ns) && publisherOf(manifest.id) !== OFFICIAL_PUBLISHER)
+        throw new Error(`${manifest.id}: namespace "${ns}" is reserved`);
+    if (manifest.main === null && !manifest.languages.length)
+        throw new Error(`${manifest.id}: "main" is null, so the plugin has no code; it must add a language under "languages"`);
+    if (manifest.context === "full") {
+        if (manifest.main === null)
+            throw new Error(`${manifest.id}: a full-mode plugin needs "main", the cordis plugin it runs`);
+        if (!manifest.engines.tomrade)
+            throw new Error(`${manifest.id}: a full-mode plugin names the Tomrade versions it works with in "engines.tomrade"`);
+        if (manifest.languages.length)
+            throw new Error(`${manifest.id}: a full-mode plugin adds its languages from its own code (ctx.settings.addLanguage), not under "languages"`);
+    }
+    else if (manifest.rows.length)
+        throw new Error(`${manifest.id}: "rows" change Tomrade's own composition, which takes "context": "full"`);
+    const ids = manifest.rows.map((r) => r.id);
+    const repeated = ids.find((id, i) => ids.indexOf(id) !== i);
+    if (repeated)
+        throw new Error(`${manifest.id}: the row "${repeated}" is listed twice`);
+    const tags = manifest.languages.map((l) => l.tag);
+    const twice = tags.find((t, i) => tags.indexOf(t) !== i);
+    if (twice)
+        throw new Error(`${manifest.id}: the language "${twice}" is listed twice`);
+    return manifest;
+}
+export const publisherOf = (id) => id.split("/")[0];
+export const nameOf = (id) => id.split("/")[1] ?? id;
+/** The prefix every id the plugin registers carries, and the name of its tables. */
+export const namespaceOf = (manifest) => manifest.namespace ?? nameOf(manifest.id).replace(/-/g, "_");
+export const ownsId = (namespace, id) => id === namespace || [".", "-", "_"].some((sep) => id.startsWith(namespace + sep));
+export function assertOwned(namespace, id, kind) {
+    if (!ownsId(namespace, id))
+        throw new Error(`${kind} "${id}" must be named "${namespace}" or start with "${namespace}." "${namespace}-" or "${namespace}_"`);
+}
+/**
+ * High risk is labelled, not refused: running with Tomrade's whole context or
+ * changing its own rows, running programs, reading anywhere on disk, or talking
+ * to any host. Elevated is what a person should still see.
+ */
+export function riskOf(manifest) {
+    const p = manifest.permissions;
+    const full = manifest.context === "full";
+    const high = [full && "full", full && manifest.rows?.length && "rows", p.exec && "exec", p.fs === "any" && "fs-any", p.network.includes("*") && "network-any"].filter(Boolean);
+    const elevated = [
+        p.network.length && !p.network.includes("*") && "network",
+        p.fs === "project" && "fs-project",
+        [...manifest.inject, ...manifest.optional].includes("db") && "db",
+        // A model provider reads the conversations of the profiles on it, and their keys.
+        [...manifest.inject, ...manifest.optional].includes("models") && "models",
+        // A window that takes keys could pass itself off as another app's: worth a look before installing.
+        p.window && "window"
+    ].filter(Boolean);
+    return { level: high.length ? "high" : elevated.length ? "elevated" : "low", reasons: [...high, ...elevated] };
+}
+/** OSI-approved licenses the store accepts without a second look. */
+export const OSI_LICENSES = new Set([
+    "0BSD", "AGPL-3.0", "AGPL-3.0-only", "AGPL-3.0-or-later", "Apache-2.0", "Artistic-2.0", "BSD-2-Clause", "BSD-3-Clause", "BSL-1.0", "CDDL-1.0", "EPL-1.0", "EPL-2.0",
+    "EUPL-1.2", "GPL-2.0", "GPL-2.0-only", "GPL-2.0-or-later", "GPL-3.0", "GPL-3.0-only", "GPL-3.0-or-later", "ISC", "LGPL-2.1", "LGPL-2.1-only", "LGPL-2.1-or-later",
+    "LGPL-3.0", "LGPL-3.0-only", "LGPL-3.0-or-later", "MIT", "MIT-0", "MPL-2.0", "MS-PL", "MulanPSL-2.0", "NCSA", "OSL-3.0", "PostgreSQL", "Unlicense", "UPL-1.0", "Zlib"
+]);
+export const isOpenSource = (license) => license.split(/\s+OR\s+/i).some((l) => OSI_LICENSES.has(l.replace(/[()]/g, "").trim()));
+//# sourceMappingURL=manifest.js.map