attention-manifest-protocol 0.4.2 → 0.4.3

package/lib/file/service.js

@@ -0,0 +1,663 @@
+/**
+ * Agent-facing filesystem service.
+ *
+ * One handle is bound to exactly one session. The service authenticates the
+ * bearer token on every call, resolves paths through that session's sandbox and
+ * keeps all trees, annotations, graph caches and write journals per session.
+ * The token is never part of a tool schema, so a model cannot forward or widen
+ * it; the host that opens the session is the only party that ever sees it.
+ *
+ * Read methods are synchronous because the underlying filesystem APIs are; only
+ * `write` and the tool dispatcher are async. The JSON-RPC adapter awaits the
+ * same `call` entry point, so a future async parser does not need a second wire
+ * contract.
+ */
+import { Buffer } from "node:buffer";
+import { parseToolCall } from "../boundary/toolCall.js";
+import { BoundaryRejection } from "../error/boundaryRejection.js";
+import { isSessionError } from "../session/errors.js";
+import { SessionRegistry } from "../session/registry.js";
+import { filesystemToolDefinitions, filesystemToolLeaves, FilesystemProtocol, FilesystemProtocolVersion } from "../protocol/filesystem.js";
+import { buildOutline } from "../outline/outline.js";
+import { filterOutline, wireOutline } from "../outline/outlineIndex.js";
+import { listDirectory } from "./directory.js";
+import { wireNode, wireTree } from "./file.js";
+import { extractImports } from "./importGraph.js";
+import { extractExports } from "./exportGraph.js";
+import { isOfficeFile, officeExports, officeReferences, parseOffice } from "../outline/office.js";
+import { buildSyntaxTree } from "./syntaxTree.js";
+import { wireSyntaxTree } from "../syntax/syntaxTree.js";
+import { buildDependencyReport, graphFromImports } from "./dependency.js";
+import { isFilesystemError } from "./errors.js";
+import { readPage } from "./read.js";
+import { writeFile } from "./write.js";
+import { SessionRuntime } from "./runtime.js";
+const Defaults = {
+    maxTreeNodes: 20_000,
+    maxReadBytes: 8 * 1024 * 1024,
+    maxWriteBytes: 4 * 1024 * 1024,
+    maxResponseChars: 262_144,
+    maxToolCalls: 5000,
+    maxGraphFiles: 2000,
+    maxGraphBytes: 32 * 1024 * 1024,
+};
+const base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const decodeBase64 = (text) => {
+    if (!base64Pattern.test(text) || text.length % 4 !== 0) {
+        throw new FilesystemArgumentError();
+    }
+    return new Uint8Array(Buffer.from(text, "base64"));
+};
+/**
+ * Internal marker for a shape error that the schema could not express; mapped
+ * to `invalid_arguments` at the boundary.
+ */
+class FilesystemArgumentError extends Error {
+}
+export class FilesystemService {
+    registry;
+    store;
+    annotations;
+    limits;
+    timeZone;
+    followSymlinks;
+    includeHidden;
+    runtimes = new Map();
+    graphs = new Map();
+    calls = 0;
+    constructor(options) {
+        if (options === null || typeof (options) !== "object" || options.registry === (void 0)) {
+            throw new Error("filesystem service requires a session registry");
+        }
+        this.registry = options.registry;
+        this.store = options.store;
+        this.annotations = options.annotations;
+        this.limits = { ...Defaults, ...options.limits };
+        for (const key of Object.keys(options.limits ?? {})) {
+            const value = this.limits[key];
+            if (!Number.isSafeInteger(value) || value < 1) {
+                throw new Error(`invalid filesystem service limit ${key}`);
+            }
+        }
+        this.timeZone = options.timeZone === "utc" ? "utc" : "local";
+        this.followSymlinks = options.followSymlinks === true;
+        this.includeHidden = options.includeHidden === true;
+    }
+    /**
+     * Authenticate one session and return its handle. A new handle for the same
+     * session shares the runtime so two UI components do not build two trees.
+     */
+    bind(sessionId, token) {
+        const authentication = this.registry.authenticate(sessionId, token);
+        let runtime = this.runtimes.get(sessionId);
+        if (runtime === (void 0)) {
+            runtime = new SessionRuntime(authentication.descriptor, {
+                ...(this.store === (void 0) ? {} : { store: this.store }),
+                ...(this.annotations === (void 0) ? {} : { annotations: this.annotations }),
+                timeZone: this.timeZone,
+                followSymlinks: this.followSymlinks,
+                includeHidden: this.includeHidden,
+            });
+            this.runtimes.set(sessionId, runtime);
+        }
+        return new FilesystemSession(this, runtime, token);
+    }
+    /**
+     * Drop one session's caches. Hosts call this after revoke/expiry; a later
+     * `bind` recreates the runtime, but the tree is rebuilt from disk rather
+     * than inherited from the previous identity.
+     */
+    /**
+     * Public descriptor view for the `session` tool. Keeps the registry field
+     * private instead of reaching through an index signature from the handle.
+     */
+    summary(sessionId) {
+        return this.registry.summary(sessionId);
+    }
+    dispose(sessionId) {
+        const runtime = this.runtimes.get(sessionId);
+        if (runtime !== (void 0)) {
+            runtime.dispose();
+            this.runtimes.delete(sessionId);
+        }
+        this.graphs.clear();
+    }
+    /**
+     * JSON-RPC / registry entry. Returns a complete envelope; it never throws.
+     */
+    async call(session, name, raw) {
+        try {
+            return await session.dispatch(name, raw);
+        }
+        catch (error) {
+            return session.errorResponse(this.mapError(error));
+        }
+    }
+    /**
+     * Count one business call and enforce the service-wide ceiling.
+     */
+    admit() {
+        if (this.calls >= this.limits.maxToolCalls) {
+            throw new FilesystemArgumentError();
+        }
+        this.calls += 1;
+    }
+    limitsFor() {
+        return { ...this.limits };
+    }
+    /**
+     * Import facts for one file. Office containers are not source text, so they
+     * go through `office.ts` and expose hyperlinks, external workbook links and
+     * embedded objects as external edges instead of failing as binary.
+     */
+    importReport(runtime, path) {
+        if (!isOfficeFile(path)) {
+            return extractImports(runtime.sandbox, path);
+        }
+        const document = parseOffice(runtime.sandbox, path);
+        const imports = [];
+        const external = [];
+        const seen = new Set();
+        const targets = [...document.imports];
+        for (const reference of officeReferences(document)) {
+            if (reference.kind === "hyperlink" || reference.kind === "external-link" || reference.kind === "embedded" || reference.kind === "formula") {
+                targets.push(reference.target);
+            }
+        }
+        for (const specifier of targets) {
+            if (specifier.length === 0 || seen.has(specifier)) {
+                continue;
+            }
+            seen.add(specifier);
+            imports.push({
+                from: path,
+                to: specifier,
+                specifier,
+                kind: "static",
+                line: 1,
+                resolved: false,
+                external: true,
+            });
+            external.push(specifier);
+        }
+        return {
+            path,
+            fingerprint: document.fingerprint,
+            imports,
+            importedBy: [],
+            external,
+            unresolved: [],
+            truncated: false,
+        };
+    }
+    /**
+     * Export facts for one file. Office exports are named ranges, bookmarks and
+     * tables; their kind is intentionally generic because the container does not
+     * distinguish a symbol the way a source file does.
+     */
+    exportReport(runtime, path) {
+        if (!isOfficeFile(path)) {
+            return extractExports(runtime.sandbox, path);
+        }
+        const document = parseOffice(runtime.sandbox, path);
+        const exports = officeExports(document).map((name) => ({
+            name,
+            kind: "const",
+            line: 1,
+            signature: "office export",
+        }));
+        return {
+            path,
+            fingerprint: document.fingerprint,
+            exports,
+            reexports: [],
+            truncated: false,
+        };
+    }
+    /**
+     * Build or reuse the dependency graph for one root. The tree revision is the
+     * cache key; a write refreshes the tree and therefore invalidates the graph.
+     */
+    graphFor(runtime, rootId) {
+        const tree = runtime.treeFor(runtime.descriptor.roots.find((root) => root.id === rootId));
+        const revision = tree.revision();
+        const cached = this.graphs.get(rootId);
+        if (cached !== (void 0) && cached.revision === revision) {
+            return cached;
+        }
+        const reports = [];
+        let bytes = 0;
+        const files = [];
+        for (const child of tree.snapshot().root.children) {
+            files.push(child);
+        }
+        const stack = [...files].reverse();
+        while (stack.length > 0 && reports.length < this.limits.maxGraphFiles) {
+            const node = stack.pop();
+            if (node.type === "Directory") {
+                for (let index = node.children.length - 1; index >= 0; index -= 1) {
+                    stack.push(node.children[index]);
+                }
+                continue;
+            }
+            if (bytes + Number(node.bytes) > this.limits.maxGraphBytes) {
+                break;
+            }
+            bytes += Number(node.bytes);
+            try {
+                reports.push(this.importReport(runtime, node.path));
+            }
+            catch {
+                continue;
+            }
+        }
+        const graph = graphFromImports(revision, reports, true);
+        const byPath = new Map(reports.map((report) => [report.path, report]));
+        const entry = { revision, graph, reports: byPath };
+        this.graphs.set(rootId, entry);
+        return entry;
+    }
+    /**
+     * Typed helpers used by the hook layer and direct embedders. They throw the
+     * classified error instead of returning an envelope; the tool surface wraps
+     * them below.
+     */
+    read(runtime, request) {
+        return readPage(runtime.sandbox, request, { maxBytes: Math.min(runtime.descriptor.permissions.maxReadBytes, this.limits.maxReadBytes) });
+    }
+    async write(runtime, request) {
+        const { rooted, tree } = runtime.resolve(request.path, request.mode === "create" ? "create" : "write");
+        const settings = {
+            maxBytes: Math.min(runtime.descriptor.permissions.maxWriteBytes, this.limits.maxWriteBytes),
+            journal: (entry) => runtime.journal(entry),
+            tree,
+            timeZone: this.timeZone,
+        };
+        const result = await writeFile(runtime.sandbox, runtime.descriptor.id, request, settings);
+        runtime.persist(rooted.root, tree.snapshot());
+        return result;
+    }
+    outline(runtime, request) {
+        const { rooted, node, tree } = runtime.node(request.path, "read");
+        const cached = this.store === (void 0) ? (void 0) : this.store.loadOutline(rooted.root.id, rooted.relative, node.fingerprint);
+        const result = cached ??
+            buildOutline(runtime.sandbox, rooted.relative, {
+                maxNodes: request.maxNodes,
+                maxDepth: request.maxDepth,
+                symbols: request.symbols,
+                ...(node.type === "File" ? { anchor: { file: node } } : { anchor: { directory: node } }),
+            }, node.type === "File" ? { file: node } : { directory: node });
+        if (cached === (void 0) && this.store !== (void 0)) {
+            this.store.saveOutline(rooted.root.id, result);
+        }
+        const filtered = request.query === (void 0) && request.startLine === (void 0) && request.endLine === (void 0)
+            ? result
+            : filterOutline(result, {
+                ...(request.query === (void 0) ? {} : { prefix: request.query }),
+                ...(request.startLine === (void 0) ? {} : { startLine: request.startLine }),
+                ...(request.endLine === (void 0) ? {} : { endLine: request.endLine }),
+                limit: 200,
+            });
+        void tree;
+        return filtered;
+    }
+    imports(runtime, request) {
+        const { rooted, node } = runtime.node(request.path, "read");
+        if (node.type !== "File") {
+            throw new FilesystemArgumentError();
+        }
+        const report = this.importReport(runtime, rooted.relative);
+        const direction = request.direction ?? "outgoing";
+        if (direction === "outgoing") {
+            return { ...report, importedBy: [] };
+        }
+        const graph = this.graphFor(runtime, rooted.root.id);
+        const incoming = [];
+        const seen = new Set();
+        for (const source of graph.reports.values()) {
+            for (const edge of source.imports) {
+                if (edge.to !== rooted.relative || edge.external || !edge.resolved) {
+                    continue;
+                }
+                const key = `${edge.from}|${edge.to}|${edge.line}|${edge.specifier}|${edge.kind}`;
+                if (seen.has(key)) {
+                    continue;
+                }
+                seen.add(key);
+                incoming.push(edge);
+            }
+        }
+        return { ...report, importedBy: incoming.slice(0, Math.max(1, request.limit ?? 200)) };
+    }
+    exports(runtime, request) {
+        const { rooted, node } = runtime.node(request.path, "read");
+        if (node.type !== "File") {
+            throw new FilesystemArgumentError();
+        }
+        const report = this.exportReport(runtime, rooted.relative);
+        return request.includeReexports === true ? report : { ...report, reexports: [] };
+    }
+    /**
+     * Lossless syntax tree. Read-only: the parser never imports or evaluates the
+     * target file.
+     */
+    ast(runtime, request) {
+        return buildSyntaxTree(runtime.sandbox, request.path, {
+            ...(request.maxBytes === (void 0) ? {} : { maxBytes: request.maxBytes }),
+            ...(request.maxTokens === (void 0) ? {} : { maxTokens: request.maxTokens }),
+            ...(request.maxNodes === (void 0) ? {} : { maxNodes: request.maxNodes }),
+        });
+    }
+    dependency(runtime, request) {
+        const root = runtime.descriptor.roots[0];
+        const graph = this.graphFor(runtime, root.id);
+        const roots = (request.roots ?? []).map((entry) => runtime.sandbox.resolve(entry, "read").relative);
+        return buildDependencyReport(graph.graph, graph.revision, {
+            mode: request.mode,
+            ...(roots.length === 0 ? {} : { roots }),
+            ...(request.direction === (void 0) ? {} : { direction: request.direction }),
+            ...(request.depth === (void 0) ? {} : { depth: request.depth }),
+            ...(request.limit === (void 0) ? {} : { limit: request.limit }),
+            ...(request.includeExternal === (void 0) ? {} : { includeExternal: request.includeExternal }),
+        });
+    }
+    mapError(error) {
+        if (isFilesystemError(error)) {
+            return error.code;
+        }
+        if (isSessionError(error)) {
+            if (error.code === "invalid_identity" || error.code === "session_forbidden") {
+                return "permission_denied";
+            }
+            if (error.code === "invalid_arguments") {
+                return "invalid_arguments";
+            }
+            return "session_unavailable";
+        }
+        if (error instanceof BoundaryRejection || error instanceof FilesystemArgumentError) {
+            return "invalid_arguments";
+        }
+        return "internal_error";
+    }
+}
+/**
+ * Bound session handle. It is the only object a transport needs; the token stays
+ * private and is re-checked on every call.
+ */
+export class FilesystemSession {
+    sessionId;
+    service;
+    token;
+    runtime;
+    calls = 0;
+    constructor(service, runtime, token) {
+        this.service = service;
+        this.runtime = runtime;
+        this.sessionId = runtime.descriptor.id;
+        this.token = token;
+    }
+    get descriptor() {
+        return this.runtime.descriptor;
+    }
+    tools() {
+        return filesystemToolDefinitions();
+    }
+    /**
+     * Typed read for direct embedders and the hook layer. It throws the
+     * classified error instead of returning the JSON envelope.
+     */
+    read(request) {
+        this.refresh();
+        return this.service.read(this.runtime, request);
+    }
+    /**
+     * Typed write. The only mutating operation in the whole filesystem surface.
+     */
+    async write(request) {
+        this.refresh();
+        return this.service.write(this.runtime, request);
+    }
+    /**
+     * Typed outline query.
+     */
+    outline(request) {
+        this.refresh();
+        return this.service.outline(this.runtime, request);
+    }
+    /**
+     * Typed import report.
+     */
+    imports(request) {
+        this.refresh();
+        return this.service.imports(this.runtime, request);
+    }
+    /**
+     * Typed export report.
+     */
+    exports(request) {
+        this.refresh();
+        return this.service.exports(this.runtime, request);
+    }
+    /**
+     * Typed dependency query.
+     */
+    dependency(request) {
+        this.refresh();
+        return this.service.dependency(this.runtime, request);
+    }
+    /**
+     * Typed syntax-tree query. Read-only; the parser never executes the file.
+     */
+    ast(request) {
+        this.refresh();
+        return this.service.ast(this.runtime, request);
+    }
+    /**
+     * Current root revision for cache keys and audit rows.
+     */
+    revision() {
+        this.refresh();
+        return this.revisionOf();
+    }
+    /**
+     * Re-authenticate before each call. A host that revokes or expires a session
+     * therefore does not need to reach into every live handle.
+     */
+    refresh() {
+        this.service.bind(this.sessionId, this.token);
+    }
+    async dispatch(name, raw) {
+        this.service.admit();
+        if (this.calls >= this.service.limitsFor().maxToolCalls) {
+            return this.errorResponse("quota_exceeded");
+        }
+        this.calls += 1;
+        const leaf = filesystemToolLeaves.get(name);
+        const tool = this.tools().find((entry) => entry.name === name);
+        if (leaf === (void 0) || tool === (void 0)) {
+            return this.errorResponse("unknown_tool");
+        }
+        let args;
+        try {
+            args = parseToolCall(tool, raw).args;
+        }
+        catch (error) {
+            if (error instanceof BoundaryRejection) {
+                return this.errorResponse("invalid_arguments");
+            }
+            throw error;
+        }
+        try {
+            this.refresh();
+        }
+        catch (error) {
+            return this.errorResponse(this.service.mapError(error));
+        }
+        const data = await this.dataFor(leaf, args);
+        const response = {
+            protocol: FilesystemProtocol,
+            version: FilesystemProtocolVersion,
+            ok: true,
+            revision: this.revisionOf(),
+            session: this.sessionId,
+            data,
+        };
+        if (JSON.stringify(response).length > this.service.limitsFor().maxResponseChars) {
+            return this.errorResponse("response_too_large");
+        }
+        return response;
+    }
+    async dataFor(leaf, args) {
+        switch (leaf) {
+            case "session": {
+                const summary = this.service.summary(this.sessionId);
+                return {
+                    agentId: summary.agentId,
+                    label: summary.label,
+                    roots: summary.roots,
+                    permissions: this.runtime.descriptor.permissions,
+                    createdAt: summary.createdAt,
+                    expiresAt: summary.expiresAt,
+                    remainingMs: summary.remainingMs,
+                    revision: summary.revision,
+                    limits: this.service.limitsFor(),
+                };
+            }
+            case "file": {
+                const { node, revision } = this.runtime.node(args.path, "read");
+                const depth = typeof (args.depth) === "number" ? args.depth : 1;
+                const offset = typeof (args.offset) === "number" ? args.offset : 0;
+                const limit = typeof (args.limit) === "number" ? args.limit : 50;
+                return { node: wireTree(node, depth, offset, limit), revision };
+            }
+            case "directory": {
+                const { rooted, tree } = this.runtime.resolve(args.path, "read");
+                const listing = listDirectory(tree, rooted.relative, typeof (args.offset) === "number" ? args.offset : 0, typeof (args.limit) === "number" ? args.limit : 50);
+                return { ...listing };
+            }
+            case "read": {
+                const page = this.service.read(this.runtime, {
+                    path: args.path,
+                    ...(args.startLine === (void 0) ? {} : { startLine: args.startLine }),
+                    ...(args.maxLines === (void 0) ? {} : { maxLines: args.maxLines }),
+                    ...(args.maxBytes === (void 0) ? {} : { maxBytes: args.maxBytes }),
+                    ...(args.includeLineNumbers === (void 0) ? {} : { includeLineNumbers: args.includeLineNumbers }),
+                });
+                return { ...page, totalLines: page.totalLines.toString(), totalBytes: page.totalBytes.toString() };
+            }
+            case "write": {
+                const hasText = typeof (args.content) === "string";
+                const hasBase64 = typeof (args.contentBase64) === "string";
+                if (hasText === hasBase64) {
+                    return this.invalid();
+                }
+                const content = hasText ? args.content : decodeBase64(args.contentBase64);
+                const request = {
+                    path: args.path,
+                    content,
+                    ...(args.encoding === (void 0) ? {} : { encoding: args.encoding }),
+                    ...(args.mode === (void 0) ? {} : { mode: args.mode }),
+                    ...(args.expectFingerprint === (void 0) ? {} : { expectFingerprint: args.expectFingerprint }),
+                    ...(args.createParents === (void 0) ? {} : { createParents: args.createParents }),
+                    ...(args.dryRun === (void 0) ? {} : { dryRun: args.dryRun }),
+                };
+                const result = await this.service.write(this.runtime, request);
+                return {
+                    node: wireNode(result.node),
+                    previousFingerprint: result.previousFingerprint,
+                    created: result.created,
+                    dryRun: result.dryRun,
+                    bytesWritten: result.bytesWritten.toString(),
+                    revision: result.revision,
+                };
+            }
+            case "outline": {
+                const result = this.service.outline(this.runtime, {
+                    path: args.path,
+                    ...(args.maxNodes === (void 0) ? {} : { maxNodes: args.maxNodes }),
+                    ...(args.maxDepth === (void 0) ? {} : { maxDepth: args.maxDepth }),
+                    ...(args.query === (void 0) ? {} : { query: args.query }),
+                    ...(args.startLine === (void 0) ? {} : { startLine: args.startLine }),
+                    ...(args.endLine === (void 0) ? {} : { endLine: args.endLine }),
+                });
+                return { ...wireOutline(result) };
+            }
+            case "import": {
+                const report = this.service.imports(this.runtime, {
+                    path: args.path,
+                    ...(args.direction === (void 0) ? {} : { direction: args.direction }),
+                    ...(args.depth === (void 0) ? {} : { depth: args.depth }),
+                    ...(args.includeExternal === (void 0) ? {} : { includeExternal: args.includeExternal }),
+                    ...(args.limit === (void 0) ? {} : { limit: args.limit }),
+                });
+                return { ...report };
+            }
+            case "export": {
+                const report = this.service.exports(this.runtime, {
+                    path: args.path,
+                    ...(args.includeReexports === (void 0) ? {} : { includeReexports: args.includeReexports }),
+                });
+                return { ...report };
+            }
+            case "ast": {
+                const tree = this.service.ast(this.runtime, {
+                    path: args.path,
+                    ...(args.maxBytes === (void 0) ? {} : { maxBytes: args.maxBytes }),
+                    ...(args.maxTokens === (void 0) ? {} : { maxTokens: args.maxTokens }),
+                    ...(args.maxNodes === (void 0) ? {} : { maxNodes: args.maxNodes }),
+                });
+                return { ...wireSyntaxTree(tree) };
+            }
+            case "dependency": {
+                const report = this.service.dependency(this.runtime, {
+                    mode: args.mode,
+                    ...(args.roots === (void 0) ? {} : { roots: args.roots }),
+                    ...(args.direction === (void 0) ? {} : { direction: args.direction }),
+                    ...(args.depth === (void 0) ? {} : { depth: args.depth }),
+                    ...(args.limit === (void 0) ? {} : { limit: args.limit }),
+                    ...(args.includeExternal === (void 0) ? {} : { includeExternal: args.includeExternal }),
+                });
+                return { ...report };
+            }
+            default: {
+                return this.invalid();
+            }
+        }
+    }
+    invalid() {
+        throw new FilesystemArgumentError();
+    }
+    revisionOf() {
+        try {
+            const root = this.runtime.descriptor.roots[0];
+            return this.runtime.revisionFor(root);
+        }
+        catch {
+            return `ses.${this.runtime.descriptor.revision}`;
+        }
+    }
+    errorResponse(code) {
+        return {
+            protocol: FilesystemProtocol,
+            version: FilesystemProtocolVersion,
+            ok: false,
+            revision: `ses.${this.runtime.descriptor.revision}`,
+            session: this.sessionId,
+            error: { code, message: code },
+        };
+    }
+}
+/**
+ * Small helper for hosts that want one descriptor without a live handle.
+ */
+export const filesystemSessionSummary = (descriptor) => ({
+    sessionId: descriptor.id,
+    agentId: descriptor.agentId,
+    label: descriptor.label,
+    status: descriptor.status,
+    roots: descriptor.roots.map((root) => ({ id: root.id, writable: root.writable, excludes: root.exclude.length })),
+    permissions: { ...descriptor.permissions },
+    createdAt: descriptor.createdAt,
+    expiresAt: descriptor.expiresAt,
+    revision: descriptor.revision,
+});

package/lib/file/syntaxTree.d.ts

@@ -0,0 +1,7 @@
+import type { SyntaxTree, SyntaxTreeOptions } from "../syntax/syntaxTree.js";
+import type { PathSandbox } from "./path.js";
+/**
+ * Read and parse one file through the session sandbox. The parser is read-only:
+ * it never evaluates the file, resolves an import or launches a subprocess.
+ */
+export declare const buildSyntaxTree: (sandbox: PathSandbox, path: string, options?: SyntaxTreeOptions) => SyntaxTree;