@theoremjs/studio 0.0.0-stage → 0.3.2

package/server/test-connection.js

@@ -0,0 +1,362 @@
+/**
+ * Asks a draft HTTP or MCP tool's endpoint one request, through the kernel's network guard, so the
+ * builder sees whether it answers before a model calls it.
+ *
+ * @module
+ */
+import { buildHttpToolTarget, credentialPlacement, errorKind, fetchGuarded, isUnsupportedMcpProtocolError, MCP_PROTOCOL_VERSIONS, parseMcpRpcResponse, TheoremError, withCredentialQuery, z, } from '@theoremjs/agents';
+import { caughtStatus, clientError } from '@theoremjs/agents/host';
+import { readBody } from '@theoremjs/react/server';
+/** A draft's network guardrail, as the screen sends it beside the test. */
+const draftNetworkSchema = z
+    .object({
+    allowPrivateNetworks: z.boolean().optional(),
+    allowedHosts: z.array(z.string().min(1).max(253)).max(64).optional(),
+    allowedSchemes: z.array(z.string().min(1).max(32)).max(8).optional(),
+})
+    .strict()
+    .optional();
+function elapsedSince(start) {
+    return Date.now() - start;
+}
+/** Where the test credential goes: wherever the kernel would put the tool's own. */
+function probeCredential(auth, testCredential) {
+    if (!auth?.type || !testCredential)
+        return { headers: {} };
+    // A pasted OAuth token is sent as the bearer token it is.
+    const credential = auth.type === 'api_key'
+        ? { type: 'api_key', key: testCredential }
+        : { type: 'bearer', token: testCredential };
+    return credentialPlacement({
+        headerName: auth.headerName?.trim() || undefined,
+        headerPrefix: auth.headerPrefix,
+        queryParam: auth.queryParam?.trim() || undefined,
+    }, credential);
+}
+function isRedirect(res) {
+    return res.status >= 300 && res.status < 400;
+}
+function redirectResponse(res, start) {
+    const location = res.headers.get('location');
+    return Response.json({
+        ok: false,
+        status: res.status,
+        code: 'redirect',
+        error: location ? `Redirects to ${location}, which the test doesn't follow.` : 'Redirects.',
+        elapsedMs: elapsedSince(start),
+    });
+}
+/** How long a probe waits for the whole response, body included. */
+const TIMEOUT_MS = 10_000;
+/** A probe whose address can't be called. */
+const INVALID_URL = { code: 'invalid_url', error: "That isn't a web address the test can call." };
+/** Why a probe got no answer, in the test's own words: the caught failure's text stays on the server. */
+function unansweredReason(err) {
+    const kind = errorKind(err);
+    if (kind === 'blocked') {
+        return {
+            code: 'ssrf_blocked',
+            error: "The test doesn't call this address. It calls public web addresses only.",
+        };
+    }
+    if (kind === 'request')
+        return INVALID_URL;
+    if (kind === 'timeout') {
+        return {
+            code: 'network_error',
+            error: `No complete response within ${String(TIMEOUT_MS / 1000)} s.`,
+        };
+    }
+    return {
+        code: 'network_error',
+        error: "The request didn't get a response. Check that the service is up.",
+    };
+}
+/** A probe that never got an answer: refused by the network guard, or failed on the way. */
+function fetchErrorResponse(start, err) {
+    return Response.json({ ok: false, ...unansweredReason(err), elapsedMs: elapsedSince(start) });
+}
+/** How much of a response body a probe reads; enough for a large MCP tool list. */
+const MAX_BODY_BYTES = 1_000_000;
+/** Reads the body as text, stopping at `MAX_BODY_BYTES`. */
+async function readCapped(res) {
+    if (!res.body)
+        return '';
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let text = '';
+    let bytes = 0;
+    try {
+        while (bytes < MAX_BODY_BYTES) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            bytes += value.byteLength;
+            text += decoder.decode(value, { stream: true });
+        }
+    }
+    finally {
+        await reader.cancel();
+    }
+    return text + decoder.decode();
+}
+/**
+ * Fetches `url` through the kernel's network guard and reads its body within `TIMEOUT_MS`.
+ * Redirects are never followed: the credential and headers are for `url`'s origin alone. A
+ * redirect comes back as the response.
+ */
+async function fetchWithTimeout(url, init, guard) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, TIMEOUT_MS);
+    try {
+        const res = await fetchGuarded(url, { ...init, signal: controller.signal }, { followRedirects: false, ...guard });
+        return { res, text: await readCapped(res) };
+    }
+    catch (err) {
+        if (controller.signal.aborted) {
+            // labels-exempt: internal diagnostic; the visitor reads the test's own line for a timeout
+            throw new TheoremError('timeout', 'probe: no complete response in time');
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function previewResponseBody(text, contentType) {
+    if (!contentType.includes('application/json'))
+        return text.slice(0, 300);
+    try {
+        return JSON.stringify(JSON.parse(text), null, 2).slice(0, 300);
+    }
+    catch {
+        return text.slice(0, 300);
+    }
+}
+/**
+ * Why the endpoint and the sample input made no URL, naming the path parameter left unfilled. The
+ * name is read from the endpoint the visitor sent; the caught failure's text stays on the server.
+ */
+function mappingReason(endpoint, pathParams, sampleInput) {
+    const named = [...endpoint.matchAll(/\{([a-zA-Z0-9_-]+)\}/g)].map(([, name]) => name);
+    const unlisted = named.find((name) => !pathParams.includes(name));
+    if (unlisted)
+        return `{${unlisted}} is in the endpoint, but isn't one of its path parameters.`;
+    const unfilled = named.find((name) => sampleInput[name] === undefined);
+    if (unfilled)
+        return `The sample input has no value for the path parameter {${unfilled}}.`;
+    return "The endpoint and the sample input don't make a URL. Start the endpoint with a fixed scheme and host, and keep . and .. out of its path parameters.";
+}
+async function handleHttpProbe(body, start, guard) {
+    if (typeof body.endpoint !== 'string' || !body.endpoint.trim()) {
+        return Response.json({ ok: false, error: 'Endpoint URL is required' }, { status: 400 });
+    }
+    const signed = probeCredential(body.auth, body.testCredential);
+    const headers = {
+        Accept: 'application/json, text/plain, */*',
+        ...(body.headers ?? {}),
+        ...signed.headers,
+    };
+    const method = (body.method?.toUpperCase() || 'GET');
+    const sampleInput = body.sampleInput ?? {};
+    let requestUrl = body.endpoint;
+    let requestBody;
+    try {
+        const target = buildHttpToolTarget(body.endpoint, method, sampleInput, {
+            pathParams: body.pathParams,
+            queryParams: body.queryParams,
+            bodyParam: body.bodyParam,
+        });
+        requestUrl = withCredentialQuery(new URL(target.url), signed.query).href;
+        requestBody = target.body;
+    }
+    catch {
+        return Response.json({
+            ok: false,
+            code: 'invalid_mapping',
+            error: mappingReason(body.endpoint, body.pathParams ?? [], sampleInput),
+            elapsedMs: elapsedSince(start),
+        });
+    }
+    try {
+        const { res, text } = await fetchWithTimeout(requestUrl, { method, headers, ...(method === 'GET' ? {} : { body: requestBody }) }, guard);
+        if (isRedirect(res))
+            return redirectResponse(res, start);
+        const contentType = res.headers.get('content-type') || '';
+        return Response.json({
+            ok: res.ok,
+            status: res.status,
+            statusText: res.statusText,
+            contentType,
+            preview: previewResponseBody(text, contentType),
+            elapsedMs: elapsedSince(start),
+        });
+    }
+    catch (fetchErr) {
+        return fetchErrorResponse(start, fetchErr);
+    }
+}
+/** A `tools/list` call under one protocol version. */
+function mcpToolsListRequest(baseHeaders, protocolVersion) {
+    const rpcPayload = {
+        jsonrpc: '2.0',
+        id: 'test-ping-1',
+        method: 'tools/list',
+        params: {
+            _meta: {
+                'io.modelcontextprotocol/protocolVersion': protocolVersion,
+            },
+        },
+    };
+    return {
+        method: 'POST',
+        headers: { ...baseHeaders, 'MCP-Protocol-Version': protocolVersion },
+        body: JSON.stringify(rpcPayload),
+    };
+}
+/** A body that isn't JSON-RPC: a plain-text version refusal tries the next version, else it fails. */
+function nonJsonAttempt(res, text, protocolVersion, start) {
+    if (!res.ok &&
+        text.toLowerCase().includes('unsupported protocol version') &&
+        protocolVersion !== MCP_PROTOCOL_VERSIONS.at(-1)) {
+        return { status: res.status, protocolError: { code: -32600, message: text.slice(0, 300) } };
+    }
+    return {
+        response: Response.json({
+            ok: false,
+            status: res.status,
+            code: 'invalid_json',
+            error: `MCP server returned non-JSON response: ${text.slice(0, 200)}`,
+            elapsedMs: elapsedSince(start),
+        }),
+    };
+}
+/** What a JSON-RPC answer to `tools/list` says: an MCP error, not MCP at all, or the tool list. */
+function mcpAnswerResponse(body, res, rpcData, protocolVersion, start) {
+    if (rpcData.error) {
+        return Response.json({
+            ok: false,
+            status: res.status,
+            code: `mcp_error_${String(rpcData.error.code)}`,
+            error: rpcData.error.message,
+            elapsedMs: elapsedSince(start),
+        });
+    }
+    if (rpcData.jsonrpc !== '2.0' || !Array.isArray(rpcData.result?.tools)) {
+        return Response.json({
+            ok: false,
+            status: res.status,
+            code: 'not_mcp',
+            error: "Answered, but not as an MCP server: tools/list didn't return a tool list.",
+            elapsedMs: elapsedSince(start),
+        });
+    }
+    const tools = rpcData.result.tools;
+    const toolNames = tools.map((t) => t.name);
+    const targetName = body.mcpToolName?.trim();
+    return Response.json({
+        ok: res.ok,
+        status: res.status,
+        protocolVersion,
+        toolCount: tools.length,
+        tools: toolNames,
+        targetToolFound: targetName ? toolNames.includes(targetName) : undefined,
+        preview: JSON.stringify(rpcData.result ?? rpcData, null, 2).slice(0, 300),
+        elapsedMs: elapsedSince(start),
+    });
+}
+/** Asks the server for its tools under one protocol version. */
+async function attemptMcpProbe(body, url, baseHeaders, protocolVersion, start, guard) {
+    const { res, text } = await fetchWithTimeout(url, mcpToolsListRequest(baseHeaders, protocolVersion), guard);
+    if (isRedirect(res))
+        return { response: redirectResponse(res, start) };
+    let rpcData;
+    try {
+        rpcData = parseMcpRpcResponse(text);
+    }
+    catch {
+        return nonJsonAttempt(res, text, protocolVersion, start);
+    }
+    if (rpcData.error && isUnsupportedMcpProtocolError(rpcData.error)) {
+        return { status: res.status, protocolError: rpcData.error };
+    }
+    return { response: mcpAnswerResponse(body, res, rpcData, protocolVersion, start) };
+}
+async function handleMcpProbe(body, start, guard) {
+    if (typeof body.serverUrl !== 'string' || !body.serverUrl.trim()) {
+        return Response.json({ ok: false, error: 'Server URL is required' }, { status: 400 });
+    }
+    const signed = probeCredential(body.auth, body.testCredential);
+    const baseHeaders = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+        ...(body.headers ?? {}),
+        ...signed.headers,
+    };
+    const serverUrl = URL.parse(body.serverUrl);
+    if (!serverUrl) {
+        return Response.json({ ok: false, ...INVALID_URL, elapsedMs: elapsedSince(start) });
+    }
+    try {
+        const url = withCredentialQuery(serverUrl, signed.query).href;
+        let lastStatus = 0;
+        let lastProtocolError;
+        // Preferred version first; a server that refuses one is asked again under the next.
+        for (const protocolVersion of MCP_PROTOCOL_VERSIONS) {
+            const attempt = await attemptMcpProbe(body, url, baseHeaders, protocolVersion, start, guard);
+            if ('response' in attempt)
+                return attempt.response;
+            lastStatus = attempt.status;
+            lastProtocolError = attempt.protocolError;
+        }
+        return Response.json({
+            ok: false,
+            status: lastStatus || 400,
+            code: lastProtocolError
+                ? `mcp_error_${String(lastProtocolError.code)}`
+                : 'mcp_protocol_error',
+            error: lastProtocolError?.message ?? 'MCP protocol negotiation failed',
+            elapsedMs: elapsedSince(start),
+        });
+    }
+    catch (fetchErr) {
+        return fetchErrorResponse(start, fetchErr);
+    }
+}
+/**
+ * `POST <base>/test-connection`: one request to a draft HTTP or MCP tool's endpoint. It reaches
+ * public hosts only, unless `draftNetwork` is set: then it keeps to the network guardrail the
+ * draft sends (`network`), as the draft's runs do. A name is checked against private addresses
+ * only through `resolveHost`; without it, only the address as written is.
+ */
+export async function testConnection(request, options = {}) {
+    const start = Date.now();
+    try {
+        const rawBody = await readBody(request, z.unknown());
+        if (!rawBody || typeof rawBody !== 'object' || !('type' in rawBody)) {
+            return Response.json({ ok: false, error: 'Missing type in test connection request' }, { status: 400 });
+        }
+        const { type } = rawBody;
+        if (type !== 'http' && type !== 'mcp') {
+            return Response.json({ ok: false, error: 'Type must be http or mcp' }, { status: 400 });
+        }
+        const body = rawBody;
+        const sent = draftNetworkSchema.safeParse(rawBody.network);
+        if (!sent.success) {
+            throw new TheoremError('request', 'test connection: network is not a draft network guardrail'); // labels-exempt: internal diagnostic
+        }
+        const network = sent.data;
+        const guard = {
+            ...(options.resolveHost ? { resolveHost: options.resolveHost } : {}),
+            ...(options.draftNetwork && network ? { policy: network } : {}),
+        };
+        if (body.type === 'http')
+            return await handleHttpProbe(body, start, guard);
+        return await handleMcpProbe(body, start, guard);
+    }
+    catch (err) {
+        return Response.json({ ok: false, ...clientError(err) }, { status: caughtStatus(err) });
+    }
+}

package/server/test-key.d.ts

@@ -0,0 +1,2 @@
+/** `POST <base>/test-key` `{ key }`. */
+export declare function testKey(request: Request): Promise<Response>;

package/server/test-key.js

@@ -0,0 +1,83 @@
+/**
+ * Asks a key's provider whether it accepts the key, so the builder can tell a bad key
+ * from a bad setting. The key is used for this one request: never logged, kept, or echoed back.
+ */
+import { z } from '@theoremjs/agents';
+import { readBody } from '@theoremjs/react/server';
+const TIMEOUT_MS = 8000;
+const MAX_KEY_LENGTH = 512;
+const SAID_CAP = 300;
+const PROVIDERS = [
+    {
+        provider: 'google',
+        matches: (key) => key.startsWith('AIza'),
+        request: (key) => new Request('https://generativelanguage.googleapis.com/v1beta/models?pageSize=1', {
+            headers: { 'x-goog-api-key': key },
+        }),
+    },
+    {
+        provider: 'openrouter',
+        matches: (key) => key.startsWith('sk-or-'),
+        request: (key) => new Request('https://openrouter.ai/api/v1/key', {
+            headers: { Authorization: `Bearer ${key}` },
+        }),
+    },
+];
+/** The provider's own error message, if it sent one, without the key. */
+async function providerSaid(response, key) {
+    try {
+        const body = await response.json();
+        const error = body?.error;
+        const first = Array.isArray(error) ? error[0] : error;
+        const message = first?.message;
+        if (typeof message !== 'string')
+            return undefined;
+        return message.replaceAll(key, '[the key]').slice(0, SAID_CAP);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `POST <base>/test-key` `{ key }`. */
+export async function testKey(request) {
+    if (request.method !== 'POST')
+        return new Response(null, { status: 405 });
+    let key = '';
+    try {
+        const body = await readBody(request, z.unknown());
+        const value = body?.key;
+        key = typeof value === 'string' ? value.trim() : '';
+    }
+    catch {
+        return Response.json({ ok: false, error: 'Send { key }.' }, { status: 400 });
+    }
+    if (!key || key.length > MAX_KEY_LENGTH) {
+        return Response.json({ ok: false, error: 'No key to test.' }, {
+            status: 400,
+        });
+    }
+    const match = PROVIDERS.find((candidate) => candidate.matches(key));
+    if (!match) {
+        return Response.json({
+            ok: false,
+            error: 'Only Google (AIza…) and OpenRouter (sk-or-…) keys can be tested here.',
+        });
+    }
+    try {
+        const response = await fetch(match.request(key), { signal: AbortSignal.timeout(TIMEOUT_MS) });
+        const result = {
+            ok: response.ok,
+            provider: match.provider,
+            status: response.status,
+            ...(response.ok ? {} : { said: await providerSaid(response, key) }),
+        };
+        return Response.json(result);
+    }
+    catch {
+        return Response.json({
+            ok: false,
+            provider: match.provider,
+            error: `Couldn't reach ${match.provider}.`,
+        });
+    }
+}

package/server/watch.d.ts

@@ -0,0 +1,28 @@
+/** The changes under some folders, as `Deno.watchFs` gives them. */
+export interface FolderWatch extends AsyncIterable<unknown> {
+    close(): void;
+}
+export interface FileWatchOptions {
+    /** The files to watch, by absolute path. Read again after every change, since an import can add one. */
+    files(): string[];
+    /** The files that hold something other than what the project loaded from, named for the builder. */
+    changed(): Promise<string[]>;
+    /** Called with those files, once per settled run of writes. */
+    tell(files: string[]): void;
+    /** Watches folders, not their subfolders. */
+    watch(folders: string[]): FolderWatch;
+    /** How long the files must be still before the page is told, in milliseconds. */
+    settle?: number;
+}
+/**
+ * Starts watching, and answers how to stop. An editor that saves by writing a new file over the
+ * old one never touches the old one, so the folders are watched and the files are compared.
+ */
+export declare function watchFiles(options: FileWatchOptions): {
+    stop(): void;
+};
+/** The page's subscriptions to file changes, as server-sent events. */
+export declare function createWatchFeed(): {
+    tell(files: string[]): void;
+    subscribe(headers: Record<string, string>): Response;
+};

package/server/watch.js

@@ -0,0 +1,93 @@
+/**
+ * Watching a project's files for the studio's page: when the builder's editor writes one the
+ * project's setup reads, the page is told which, once the writes settle.
+ */
+import { dirname } from 'node:path';
+/**
+ * Starts watching, and answers how to stop. An editor that saves by writing a new file over the
+ * old one never touches the old one, so the folders are watched and the files are compared.
+ */
+export function watchFiles(options) {
+    const settle = options.settle ?? 150;
+    const folders = () => [...new Set(options.files().map((file) => dirname(file)))].sort();
+    let stopped = false;
+    let watching;
+    let timer;
+    const settled = async (over) => {
+        const files = await options.changed().catch(() => []);
+        if (stopped)
+            return;
+        if (files.length)
+            options.tell(files);
+        // A file in a folder not yet watched: watch again from there.
+        if (folders().join('\n') !== over)
+            watching?.close();
+    };
+    const run = async () => {
+        while (!stopped) {
+            const over = folders();
+            try {
+                watching = options.watch(over);
+                for await (const _ of watching) {
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    timer = setTimeout(() => void settled(over.join('\n')), settle);
+                }
+            }
+            catch {
+                // A folder that went away is watched again when it is back.
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+    };
+    void run();
+    return {
+        stop: () => {
+            stopped = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            watching?.close();
+        },
+    };
+}
+/** The page's subscriptions to file changes, as server-sent events. */
+export function createWatchFeed() {
+    const encoder = new TextEncoder();
+    const pages = new Set();
+    const send = (page, text) => {
+        try {
+            page.enqueue(encoder.encode(text));
+        }
+        catch {
+            pages.delete(page);
+        }
+    };
+    return {
+        tell: (files) => {
+            for (const page of pages)
+                send(page, `data: ${JSON.stringify({ files })}\n\n`);
+        },
+        subscribe: (headers) => {
+            let mine;
+            let beat;
+            const body = new ReadableStream({
+                start(controller) {
+                    mine = controller;
+                    pages.add(controller);
+                    send(controller, ': watching\n\n');
+                    // A line now and then keeps a quiet connection open.
+                    beat = setInterval(() => send(controller, ': still watching\n\n'), 25_000);
+                },
+                cancel() {
+                    if (mine)
+                        pages.delete(mine);
+                    if (beat !== undefined)
+                        clearInterval(beat);
+                },
+            });
+            return new Response(body, {
+                headers: { ...headers, 'content-type': 'text/event-stream', 'cache-control': 'no-cache' },
+            });
+        },
+    };
+}

package/server/zod-edit.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A tool's schema as the builder's file writes it in Zod: the `z.` call it starts from, each
+ * method called on it, and the object its fields are written in. Save reads a schema this way to
+ * change one part of it where that part is written, and writes a new part as Zod.
+ *
+ * @module
+ */
+import ts from 'typescript';
+import { type SourceStyle } from '../source.ts';
+import { type Env, type Located, type ProjectSource, type ShapeEntry } from './project-source.ts';
+/** One call in a schema's expression: `z.string()`, `.describe('…')`. */
+export interface ZodCall {
+    /** The method called. */
+    name: string;
+    call: ts.CallExpression;
+    source: ts.SourceFile;
+    env?: Env;
+}
+/** A schema as the files write it. */
+export interface ZodRead {
+    /** The `z.` call it starts from. */
+    base: ZodCall;
+    /** Each method called on it since, the last one first. */
+    chain: ZodCall[];
+    /** A name stands for some of it: a constant, a function's parameter. */
+    named: boolean;
+}
+/** Which side of a tool a schema checks. The kernel reads the two a little differently. */
+export type SchemaSide = 'input' | 'output';
+/** The name `source` calls Zod by, to write a new schema in it. */
+export declare function zodName(source: ts.SourceFile): string | undefined;
+/**
+ * Reads the schema an expression stands for. A name is followed to the constant it stands for,
+ * and a project function to what it returns. Undefined when it does not lead to a `z.` call.
+ */
+export declare function readZod(project: ProjectSource, at: Located): ZodRead | undefined;
+/** The first method the studio does not read a schema through: what it returns is for code to say. */
+export declare function unread(read: ZodRead): ZodCall | undefined;
+/** The last call of a method on a schema: the one that counts. */
+export declare function methodCall(read: ZodRead, name: string): ZodCall | undefined;
+/** The text of a method call with its dot, from the end of what it is called on. */
+export declare function methodSpan(call: ZodCall): {
+    start: number;
+    end: number;
+};
+/** An object schema's fields, as the files write them. */
+export interface ZodObject {
+    /** Each field by name. One an `.extend()` writes again is the one held. */
+    entries: Map<string, ShapeEntry>;
+    /** The object a new field is written in: the last `.extend()`, or the `z.object()` itself. */
+    own: {
+        node: ts.ObjectLiteralExpression;
+        source: ts.SourceFile;
+    };
+    /** Set when an `.extend()` adds to the fields. */
+    extended: boolean;
+}
+/**
+ * The fields of an object schema. Undefined for another kind of schema, and for an object whose
+ * fields the studio cannot list: a spread it could not follow, a key the file computes.
+ */
+export declare function zodObject(project: ProjectSource, read: ZodRead): ZodObject | undefined;
+/**
+ * Whether a schema is written out in full where it stands, in Zod the studio writes itself. Such
+ * a schema can be written again from its JSON Schema with nothing lost: no name stands for a part
+ * of it, and it has no check or change that only its code holds.
+ */
+export declare function isWrittenOut(project: ProjectSource, at: Located): boolean;
+/**
+ * A JSON Schema as Zod, laid out in `style`, with `name` for Zod. `optional` writes a field its
+ * object can leave out. Undefined when the studio has no Zod for it, or when the kernel would
+ * not read that Zod back as the schema the builder ran: Save then leaves it for code.
+ */
+export declare function zodSource(schema: unknown, optional: boolean, side: SchemaSide, name: string, style?: SourceStyle): string | undefined;