@tablecraft-app/plugin-api 0.0.0-stage → 1.2.0

package/dist/inspection.js

@@ -0,0 +1,21 @@
+/** How loudly the console marks a problem (plan 108): red wavy, amber wavy, or muted dotted. */
+export const PROBLEM_SEVERITIES = ["error", "warning", "weak"];
+/**
+ * The inspections `sqlInspector` runs. The ids are DataGrip's, so a `-- noinspection <Id>` comment
+ * written there silences the same check here.
+ */
+export const INSPECTION_IDS = [
+    "SqlSyntax",
+    "SqlResolve",
+    "SqlAmbiguousColumn",
+    "SqlReservedWordAsName",
+    "SqlInsertValues",
+    "SqlWithoutWhere",
+    "SqlNullComparison",
+    "SqlConstantCondition",
+    "SqlUnusedCte",
+    "SqlDuplicateAlias",
+    "SqlRedundantOrderingDirection",
+    "SqlRedundantAlias",
+    "SqlRedundantElseNull",
+];

package/dist/keyspace.d.ts

@@ -0,0 +1,180 @@
+import type { ExecuteResult } from "./plugin.js";
+import type { WireValue } from "./values.js";
+/** The key types the key tree tells apart (decision 113); a module type such as RedisJSON is `other`. */
+export declare const KEY_TYPES: readonly ["string", "hash", "list", "set", "zset", "stream", "json", "other"];
+export type KeyType = (typeof KEY_TYPES)[number];
+/**
+ * Bytes that are usually text, such as a key name, a hash field or a value (decision 113). `text`
+ * is the UTF-8 reading with each invalid byte written `\xNN`, as `redis-cli` prints it; `hex` is
+ * every byte in lower-case hex when the bytes are not valid UTF-8, and null when they are. Sent
+ * back to the plugin, `hex` wins when present.
+ */
+export interface KeyBytes {
+    readonly text: string;
+    readonly hex: string | null;
+}
+/** A key's name: bytes, since a key may be any binary string. */
+export type KeyName = KeyBytes;
+/** One logical database of the keyspace: Redis' `db0`–`db15`, or the one database of a cluster. */
+export interface KeyDatabase {
+    readonly index: number;
+    readonly keys: number;
+    /** Keys with a time to live. */
+    readonly expires: number;
+    /** The database the connection is configured with. */
+    readonly current: boolean;
+}
+export interface KeyScanRequest {
+    readonly database: number;
+    /** Null starts a pass; otherwise what the last `KeyScan.cursor` said, opaque to the host. */
+    readonly cursor: string | null;
+    /** A glob, as `SCAN … MATCH` takes it; `*` for every key. */
+    readonly match: string;
+    readonly type: KeyType | null;
+    /**
+     * The batch the server is asked to look at per round trip, not a promise of how many keys come
+     * back; absent, the datasource's own setting.
+     */
+    readonly count?: number;
+}
+export interface KeyScan {
+    readonly keys: readonly KeyName[];
+    /** Null when the pass reached the end. */
+    readonly cursor: string | null;
+    /** Keys the server looked at, matching or not, so the host can say how far the pass got. */
+    readonly scanned: number;
+}
+export interface KeyInfo {
+    readonly key: KeyName;
+    /** Null when the key does not exist (any more). */
+    readonly type: KeyType | null;
+    /** The server's name for the type, such as `ReJSON-RL` for `other` and `json`. */
+    readonly typeName: string | null;
+    /** Milliseconds left to live; null without an expiry. */
+    readonly ttlMs: number | null;
+}
+/** What the key tab's header shows; each field null when the server or its ACL would not say. */
+export interface KeyDetails extends KeyInfo {
+    /** Fields, elements, members, entries or bytes, by type. */
+    readonly length: number | null;
+    readonly memoryBytes: number | null;
+    readonly encoding: string | null;
+    readonly idleSeconds: number | null;
+}
+/** Which part of a key `Keyspace.read` returns (decision 113). */
+export interface KeyReadRequest {
+    /** A glob over hash fields and set or sorted-set members. */
+    readonly match?: string;
+    /** The first stream id, `-` by default; the last is `to`, `+` by default. */
+    readonly from?: string;
+    readonly to?: string;
+    /** The first list or sorted-set index read. */
+    readonly offset?: number;
+    /** At most this many elements. */
+    readonly window: number;
+}
+/**
+ * A key's contents: the elements as a result the host opens in its grid, or, for a string or a
+ * type it does not read element by element, one value.
+ */
+export interface KeyContents {
+    readonly details: KeyDetails;
+    /** Rows of the elements: hash `field`, `value`; list `#`, `value`; and so on. Null for a string. */
+    readonly result: ExecuteResult | null;
+    /** The value of a string or of a JSON document, every byte up to the plugin's limit. */
+    readonly value: WireValue | null;
+    /** Why the contents cannot be edited, such as a value read only in part; null when they can. */
+    readonly readOnly: string | null;
+}
+/**
+ * One pending change to one key. `original` is what the element held when it was read, which a
+ * guarded apply checks first (decision 115); null for an element that did not exist.
+ */
+export type KeyChange = {
+    readonly kind: "setString";
+    readonly value: KeyBytes;
+    readonly original: KeyBytes | null;
+} | {
+    readonly kind: "setField";
+    readonly field: KeyBytes;
+    readonly value: KeyBytes;
+    readonly original: KeyBytes | null;
+} | {
+    readonly kind: "deleteField";
+    readonly field: KeyBytes;
+    readonly original: KeyBytes;
+} | {
+    readonly kind: "setIndex";
+    readonly index: number;
+    readonly value: KeyBytes;
+    readonly original: KeyBytes;
+} | {
+    readonly kind: "deleteIndex";
+    readonly index: number;
+    readonly original: KeyBytes;
+} | {
+    readonly kind: "push";
+    readonly value: KeyBytes;
+} | {
+    readonly kind: "addMember";
+    readonly member: KeyBytes;
+} | {
+    readonly kind: "deleteMember";
+    readonly member: KeyBytes;
+} | {
+    readonly kind: "setScore";
+    readonly member: KeyBytes;
+    readonly score: number;
+    readonly original: number | null;
+} | {
+    readonly kind: "addEntry";
+    readonly fields: readonly (readonly [KeyBytes, KeyBytes])[];
+} | {
+    readonly kind: "deleteEntry";
+    readonly id: string;
+};
+export interface KeyApplyOptions {
+    /** The key's type as read, or the type of the key the changes create. */
+    readonly type: KeyType;
+    /** Check every change's `original` first and refuse with `conflict` when one differs. */
+    readonly guard: boolean;
+    /** Milliseconds to live to set with the changes, for a new key; absent leaves the expiry alone. */
+    readonly ttlMs?: number;
+}
+export interface KeyApplied {
+    /** The commands that ran, as `preview` lists them. */
+    readonly commands: readonly string[];
+}
+/** A new expiry: milliseconds from now, an instant, or none at all. */
+export type KeyExpiry = {
+    readonly inMs: number;
+} | {
+    readonly at: string;
+} | null;
+/**
+ * The keys of a key-value store, read and changed by the plugin (decision 113). Present on a
+ * session exactly when the plugin declares `keyValue`. Calls queue on the session they hang off.
+ */
+export interface Keyspace {
+    /** What separates the levels of a key name, such as `:`, for the tree's folders. */
+    readonly delimiter: string;
+    databases(): Promise<readonly KeyDatabase[]>;
+    /** One batch of a pass over the keys; nothing ever runs `KEYS`. */
+    scan(request: KeyScanRequest): Promise<KeyScan>;
+    /** Type and expiry of each key, in order. */
+    describe(database: number, keys: readonly KeyName[]): Promise<readonly KeyInfo[]>;
+    /** A key that does not exist reads with a null `details.type` and no contents. */
+    read(database: number, key: KeyName, request: KeyReadRequest): Promise<KeyContents>;
+    /** The commands `apply` would run for `changes`, numbered by the host. Pure. */
+    preview(key: KeyName, changes: readonly KeyChange[], options: KeyApplyOptions): readonly string[];
+    /**
+     * Runs `changes` as one `MULTI`. Guarded, it first checks every `original` and rejects with
+     * `conflict`, writing nothing, when one differs.
+     */
+    apply(database: number, key: KeyName, changes: readonly KeyChange[], options: KeyApplyOptions): Promise<KeyApplied>;
+    /** Rejects with `statementFailed` when `to` exists and `overwrite` is false, or the key is gone. */
+    rename(database: number, key: KeyName, to: KeyName, overwrite: boolean): Promise<void>;
+    expire(database: number, key: KeyName, expiry: KeyExpiry): Promise<void>;
+    /** Removes the keys that exist and says how many did. */
+    remove(database: number, keys: readonly KeyName[]): Promise<number>;
+}

package/dist/keyspace.js

@@ -0,0 +1,2 @@
+/** The key types the key tree tells apart (decision 113); a module type such as RedisJSON is `other`. */
+export const KEY_TYPES = ["string", "hash", "list", "set", "zset", "stream", "json", "other"];

package/dist/manifest.d.ts

@@ -0,0 +1,200 @@
+import { z } from "zod";
+/** The file that marks a directory as a plugin (decision 005). */
+export declare const MANIFEST_FILE = "table-craft-plugin.json";
+/**
+ * What the loader reads before executing any plugin code, so an unavailable plugin can still be
+ * named in the UI.
+ */
+export declare const CONNECTION_FIELD_KINDS: readonly ["text", "number", "password", "file", "select", "checkbox"];
+export type ConnectionFieldKind = (typeof CONNECTION_FIELD_KINDS)[number];
+export declare const CONNECTION_FIELD_GROUPS: readonly ["general", "advanced"];
+export type ConnectionFieldGroup = (typeof CONNECTION_FIELD_GROUPS)[number];
+/**
+ * One control of the connection form (decision 019). `key` names the config property it fills;
+ * `secret` sends the value to the secret store instead of `datasources.json` (decision 020).
+ */
+export declare const connectionFieldSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+        number: "number";
+        text: "text";
+        select: "select";
+        password: "password";
+        file: "file";
+        checkbox: "checkbox";
+    }>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>>;
+    group: z.ZodOptional<z.ZodEnum<{
+        general: "general";
+        advanced: "advanced";
+    }>>;
+    secret: z.ZodOptional<z.ZodBoolean>;
+    visibleWhen: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        equals: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ConnectionField = z.infer<typeof connectionFieldSchema>;
+/** `server`: `scheme://user:password@host:port/database?params`; `file`: a path, bare or as a URL. */
+export declare const CONNECTION_URL_FORMS: readonly ["server", "file"];
+export type ConnectionUrlForm = (typeof CONNECTION_URL_FORMS)[number];
+/** The pieces of a connection URL a field can take; `path` belongs to the `file` form. */
+export declare const CONNECTION_URL_PARTS: readonly ["host", "port", "database", "user", "password", "path"];
+export type ConnectionUrlPart = (typeof CONNECTION_URL_PARTS)[number];
+/**
+ * How a connection URL maps onto the form's fields (decision 055), so the host parses and writes
+ * one without running plugin code. `parts` names the field each piece of the URL fills; a query
+ * parameter fills `key`, its value translated through `values` (compared case-insensitively) when
+ * given, so a value outside them is reported as ignored.
+ */
+export declare const connectionUrlSchema: z.ZodObject<{
+    schemes: z.ZodArray<z.ZodString>;
+    form: z.ZodEnum<{
+        file: "file";
+        server: "server";
+    }>;
+    parts: z.ZodRecord<z.ZodEnum<{
+        database: "database";
+        path: "path";
+        password: "password";
+        host: "host";
+        port: "port";
+        user: "user";
+    }> & z.core.$partial, z.ZodString>;
+    params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodString;
+        values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>>;
+    sets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+}, z.core.$strict>;
+export type ConnectionUrl = z.infer<typeof connectionUrlSchema>;
+/**
+ * Which fields hold the server's address (decision 070), so the host can open an SSH tunnel and
+ * hand the plugin `127.0.0.1` and the forwarded port instead. `connectTimeout`, in seconds, bounds
+ * the SSH hop too. Absent: the data source is not reached over the network and offers no tunnel.
+ */
+export declare const networkSpecSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodString;
+    connectTimeout: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type NetworkSpec = z.infer<typeof networkSpecSchema>;
+/**
+ * Which fields configure TLS (decision 072), so the dialog groups them under SSL, hints when a CA
+ * file goes unchecked, and main asks for the key passphrase only when the key file is encrypted.
+ * `mode` is the `select` of SSL modes; `verifyModes` are its values that check the server
+ * certificate. Absent: the plugin speaks no TLS the host knows about.
+ */
+export declare const tlsSpecSchema: z.ZodObject<{
+    mode: z.ZodString;
+    verifyModes: z.ZodArray<z.ZodString>;
+    caFile: z.ZodOptional<z.ZodString>;
+    certFile: z.ZodOptional<z.ZodString>;
+    keyFile: z.ZodOptional<z.ZodString>;
+    keyPassphrase: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TlsSpec = z.infer<typeof tlsSpecSchema>;
+/** The roles of `TlsSpec` that name a field, in the order the dialog draws them. */
+export declare const TLS_FIELD_ROLES: readonly ["mode", "caFile", "certFile", "keyFile", "keyPassphrase"];
+export type TlsFieldRole = (typeof TLS_FIELD_ROLES)[number];
+export declare const pluginManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    apiVersion: z.ZodString;
+    entry: z.ZodString;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        sql: "sql";
+        cancel: "cancel";
+        schemaTree: "schemaTree";
+        transactions: "transactions";
+        ddl: "ddl";
+        explain: "explain";
+        explainAnalyze: "explainAnalyze";
+        currentNamespace: "currentNamespace";
+        keepAlive: "keepAlive";
+        bulkInsert: "bulkInsert";
+        objects: "objects";
+        serverMessages: "serverMessages";
+        sessions: "sessions";
+        routineCall: "routineCall";
+        commands: "commands";
+        keyValue: "keyValue";
+        nodes: "nodes";
+        serverInfo: "serverInfo";
+    }>>;
+    highlight: z.ZodString;
+    connection: z.ZodObject<{
+        fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                number: "number";
+                text: "text";
+                select: "select";
+                password: "password";
+                file: "file";
+                checkbox: "checkbox";
+            }>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strict>>>;
+            group: z.ZodOptional<z.ZodEnum<{
+                general: "general";
+                advanced: "advanced";
+            }>>;
+            secret: z.ZodOptional<z.ZodBoolean>;
+            visibleWhen: z.ZodOptional<z.ZodObject<{
+                key: z.ZodString;
+                equals: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        url: z.ZodOptional<z.ZodObject<{
+            schemes: z.ZodArray<z.ZodString>;
+            form: z.ZodEnum<{
+                file: "file";
+                server: "server";
+            }>;
+            parts: z.ZodRecord<z.ZodEnum<{
+                database: "database";
+                path: "path";
+                password: "password";
+                host: "host";
+                port: "port";
+                user: "user";
+            }> & z.core.$partial, z.ZodString>;
+            params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                key: z.ZodString;
+                values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>>>;
+            sets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+        }, z.core.$strict>>;
+        network: z.ZodOptional<z.ZodObject<{
+            host: z.ZodString;
+            port: z.ZodString;
+            connectTimeout: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tls: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodString;
+            verifyModes: z.ZodArray<z.ZodString>;
+            caFile: z.ZodOptional<z.ZodString>;
+            certFile: z.ZodOptional<z.ZodString>;
+            keyFile: z.ZodOptional<z.ZodString>;
+            keyPassphrase: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PluginManifest = z.infer<typeof pluginManifestSchema>;

package/dist/manifest.js

@@ -0,0 +1,238 @@
+import { z } from "zod";
+import { CAPABILITIES } from "./plugin.js";
+import { parseVersion } from "./version.js";
+/** The file that marks a directory as a plugin (decision 005). */
+export const MANIFEST_FILE = "table-craft-plugin.json";
+const PLUGIN_ID = /^[a-z][a-z0-9-]*$/;
+const semver = z.string().refine((text) => parseVersion(text) !== null, { message: "expected major.minor.patch" });
+/**
+ * What the loader reads before executing any plugin code, so an unavailable plugin can still be
+ * named in the UI.
+ */
+export const CONNECTION_FIELD_KINDS = ["text", "number", "password", "file", "select", "checkbox"];
+export const CONNECTION_FIELD_GROUPS = ["general", "advanced"];
+const FIELD_KEY = /^[a-zA-Z][a-zA-Z0-9]*$/;
+/**
+ * One control of the connection form (decision 019). `key` names the config property it fills;
+ * `secret` sends the value to the secret store instead of `datasources.json` (decision 020).
+ */
+export const connectionFieldSchema = z.strictObject({
+    key: z.string().regex(FIELD_KEY, { message: "expected a camelCase config key" }),
+    label: z.string().min(1),
+    kind: z.enum(CONNECTION_FIELD_KINDS),
+    default: z.union([z.string(), z.number(), z.boolean()]).optional(),
+    required: z.boolean().optional(),
+    placeholder: z.string().optional(),
+    /** The choices of a `select`, in display order. */
+    options: z
+        .array(z.strictObject({ value: z.string(), label: z.string().min(1) }))
+        .min(1)
+        .optional(),
+    group: z.enum(CONNECTION_FIELD_GROUPS).optional(),
+    secret: z.boolean().optional(),
+    /**
+     * Draw the field only while the `select` or `checkbox` named by `key` holds `equals` (plan 058);
+     * a hidden field is neither checked nor required.
+     */
+    visibleWhen: z
+        .strictObject({ key: z.string().regex(FIELD_KEY), equals: z.union([z.string(), z.boolean()]) })
+        .optional(),
+});
+/** `server`: `scheme://user:password@host:port/database?params`; `file`: a path, bare or as a URL. */
+export const CONNECTION_URL_FORMS = ["server", "file"];
+/** The pieces of a connection URL a field can take; `path` belongs to the `file` form. */
+export const CONNECTION_URL_PARTS = ["host", "port", "database", "user", "password", "path"];
+const URL_SCHEME = /^[a-z][a-z0-9+.-]*$/;
+/**
+ * How a connection URL maps onto the form's fields (decision 055), so the host parses and writes
+ * one without running plugin code. `parts` names the field each piece of the URL fills; a query
+ * parameter fills `key`, its value translated through `values` (compared case-insensitively) when
+ * given, so a value outside them is reported as ignored.
+ */
+export const connectionUrlSchema = z.strictObject({
+    /** Without `://`; the first is the one the host writes. */
+    schemes: z.array(z.string().regex(URL_SCHEME, { message: "expected a lower-case URL scheme" })).min(1),
+    form: z.enum(CONNECTION_URL_FORMS),
+    parts: z.partialRecord(z.enum(CONNECTION_URL_PARTS), z.string().regex(FIELD_KEY)),
+    params: z
+        .array(z.strictObject({
+        name: z.string().min(1),
+        key: z.string().regex(FIELD_KEY),
+        values: z.record(z.string(), z.string()).optional(),
+    }))
+        .optional(),
+    /**
+     * Field values a scheme implies, keyed by scheme, such as `rediss` setting the TLS mode (plan
+     * 058). A pasted URL fills them; a written URL takes the first scheme whose values the config holds.
+     */
+    sets: z
+        .record(z.string().regex(URL_SCHEME), z.record(z.string().regex(FIELD_KEY), z.union([z.string(), z.number(), z.boolean()])))
+        .optional(),
+});
+/**
+ * Which fields hold the server's address (decision 070), so the host can open an SSH tunnel and
+ * hand the plugin `127.0.0.1` and the forwarded port instead. `connectTimeout`, in seconds, bounds
+ * the SSH hop too. Absent: the data source is not reached over the network and offers no tunnel.
+ */
+export const networkSpecSchema = z.strictObject({
+    host: z.string().regex(FIELD_KEY),
+    port: z.string().regex(FIELD_KEY),
+    connectTimeout: z.string().regex(FIELD_KEY).optional(),
+});
+const NETWORK_FIELD_KINDS = { host: "text", port: "number", connectTimeout: "number" };
+function networkFieldsDeclared(connection) {
+    const network = connection.network;
+    if (network === undefined)
+        return true;
+    return Object.keys(NETWORK_FIELD_KINDS).every((role) => {
+        const key = network[role];
+        if (key === undefined)
+            return true;
+        return connection.fields.some((field) => field.key === key && field.kind === NETWORK_FIELD_KINDS[role]);
+    });
+}
+/**
+ * Which fields configure TLS (decision 072), so the dialog groups them under SSL, hints when a CA
+ * file goes unchecked, and main asks for the key passphrase only when the key file is encrypted.
+ * `mode` is the `select` of SSL modes; `verifyModes` are its values that check the server
+ * certificate. Absent: the plugin speaks no TLS the host knows about.
+ */
+export const tlsSpecSchema = z.strictObject({
+    mode: z.string().regex(FIELD_KEY),
+    verifyModes: z.array(z.string().min(1)).min(1),
+    caFile: z.string().regex(FIELD_KEY).optional(),
+    certFile: z.string().regex(FIELD_KEY).optional(),
+    keyFile: z.string().regex(FIELD_KEY).optional(),
+    keyPassphrase: z.string().regex(FIELD_KEY).optional(),
+});
+/** The roles of `TlsSpec` that name a field, in the order the dialog draws them. */
+export const TLS_FIELD_ROLES = ["mode", "caFile", "certFile", "keyFile", "keyPassphrase"];
+function tlsFieldFits(role, field, tls) {
+    switch (role) {
+        case "mode": {
+            const values = new Set((field.options ?? []).map((option) => option.value));
+            return field.kind === "select" && tls.verifyModes.every((mode) => values.has(mode));
+        }
+        case "keyPassphrase":
+            return field.kind === "password" && field.secret === true;
+        default:
+            return field.kind === "file";
+    }
+}
+function tlsFieldsDeclared(connection) {
+    const tls = connection.tls;
+    if (tls === undefined)
+        return true;
+    return TLS_FIELD_ROLES.every((role) => {
+        const key = tls[role];
+        if (key === undefined)
+            return true;
+        const field = connection.fields.find((candidate) => candidate.key === key);
+        return field !== undefined && tlsFieldFits(role, field, tls);
+    });
+}
+/** Every `visibleWhen` names another field of the form, a `select` or a `checkbox`. */
+function visibilityFieldsDeclared(connection) {
+    return connection.fields.every((field) => {
+        const condition = field.visibleWhen;
+        if (condition === undefined)
+            return true;
+        const source = connection.fields.find((candidate) => candidate.key === condition.key);
+        return (source !== undefined &&
+            source !== field &&
+            (source.kind === "select" || source.kind === "checkbox") &&
+            typeof condition.equals === (source.kind === "checkbox" ? "boolean" : "string"));
+    });
+}
+/** Every scheme `url.sets` keys is one of `url.schemes`, and every value it sets is a declared field's. */
+function urlSetsDeclared(connection) {
+    const url = connection.url;
+    if (url?.sets === undefined)
+        return true;
+    return Object.entries(url.sets).every(([scheme, values]) => url.schemes.includes(scheme) &&
+        Object.keys(values).every((key) => connection.fields.some((field) => field.key === key)));
+}
+function includesAny(capabilities, ...wanted) {
+    return wanted.some((capability) => capabilities.includes(capability));
+}
+export const pluginManifestSchema = z
+    .strictObject({
+    id: z.string().regex(PLUGIN_ID, { message: "expected lower-case letters, digits and dashes" }),
+    name: z.string().min(1),
+    version: semver,
+    apiVersion: semver,
+    /** An ES module, relative to the manifest, whose default export is the `DatasourcePlugin`. */
+    entry: z.string().min(1),
+    capabilities: z.array(z.enum(CAPABILITIES)),
+    /** The highlighter the console uses for this plugin's dialect (decision 008). */
+    highlight: z.string().min(1),
+    /** The connection form, readable without running plugin code (decision 019). */
+    connection: z
+        .strictObject({
+        fields: z.array(connectionFieldSchema).min(1),
+        /** Absent: the form offers no URL to paste and the data source no Copy as URL. */
+        url: connectionUrlSchema.optional(),
+        network: networkSpecSchema.optional(),
+        tls: tlsSpecSchema.optional(),
+    })
+        .refine(networkFieldsDeclared, {
+        message: "network names a field the form does not declare, or one of the wrong kind",
+        path: ["network"],
+    })
+        .refine(tlsFieldsDeclared, {
+        message: "tls names a field the form does not declare or one of the wrong kind: mode a select offering every verify mode, files of kind file, the passphrase a secret password",
+        path: ["tls"],
+    })
+        .refine(visibilityFieldsDeclared, {
+        message: "visibleWhen names a field the form does not declare, the field itself, or one that is not a select or checkbox, or compares it with a value of the wrong type",
+        path: ["fields"],
+    })
+        .refine(urlSetsDeclared, {
+        message: "url.sets names a scheme the url does not list, or a field the form does not declare",
+        path: ["url"],
+    }),
+})
+    // A console speaks one language: SQL statements or a store's commands (decision 112).
+    .refine((manifest) => !(manifest.capabilities.includes("commands") && manifest.capabilities.includes("sql")), {
+    message: "the commands and sql capabilities exclude each other",
+    path: ["capabilities"],
+})
+    // The key tree's edits and actions are previewed and confirmed as commands (decision 113).
+    .refine((manifest) => !manifest.capabilities.includes("keyValue") || manifest.capabilities.includes("commands"), {
+    message: "the keyValue capability requires commands",
+    path: ["capabilities"],
+})
+    .refine((manifest) => !includesAny(manifest.capabilities, "nodes", "serverInfo") ||
+    includesAny(manifest.capabilities, "sql", "commands"), { message: "the nodes and serverInfo capabilities require sql or commands", path: ["capabilities"] })
+    // A definition is read through the introspector, which only `schemaTree` promises (decision 029).
+    .refine((manifest) => !manifest.capabilities.includes("ddl") || manifest.capabilities.includes("schemaTree"), {
+    message: "the ddl capability requires schemaTree",
+    path: ["capabilities"],
+})
+    // A plan is of a statement, and Analyse is Explain that also runs it (decision 031).
+    .refine((manifest) => !manifest.capabilities.includes("explain") || manifest.capabilities.includes("sql"), {
+    message: "the explain capability requires sql",
+    path: ["capabilities"],
+})
+    .refine((manifest) => !manifest.capabilities.includes("explainAnalyze") || manifest.capabilities.includes("explain"), { message: "the explainAnalyze capability requires explain", path: ["capabilities"] })
+    // A namespace is switched by a statement, and the switch is told apart by the language (decision 048).
+    .refine((manifest) => !manifest.capabilities.includes("currentNamespace") || manifest.capabilities.includes("sql"), {
+    message: "the currentNamespace capability requires sql",
+    path: ["capabilities"],
+})
+    // An import commits at boundaries it chooses and rolls back the rest (decision 046).
+    .refine((manifest) => !manifest.capabilities.includes("bulkInsert") || manifest.capabilities.includes("transactions"), { message: "the bulkInsert capability requires transactions", path: ["capabilities"] })
+    // Object DDL is planned against described tables and reads its names from the introspector (decision 052).
+    .refine((manifest) => !manifest.capabilities.includes("objects") ||
+    (manifest.capabilities.includes("sql") && manifest.capabilities.includes("schemaTree")), { message: "the objects capability requires sql and schemaTree", path: ["capabilities"] })
+    // A listed session's query opens in a console, and the engine lists sessions on its catalog or
+    // key-tree session (decision 088, plan 058).
+    .refine((manifest) => !manifest.capabilities.includes("sessions") ||
+    (includesAny(manifest.capabilities, "sql", "commands") &&
+        includesAny(manifest.capabilities, "schemaTree", "keyValue")), {
+    message: "the sessions capability requires sql or commands, and schemaTree or keyValue",
+    path: ["capabilities"],
+})
+    // A call runs in a console and is built from the routine the introspector describes (decision 090).
+    .refine((manifest) => !manifest.capabilities.includes("routineCall") ||
+    (manifest.capabilities.includes("sql") && manifest.capabilities.includes("schemaTree")), { message: "the routineCall capability requires sql and schemaTree", path: ["capabilities"] });