graphrt-plugin 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +29 -2
- package/index.d.ts +77 -0
- package/index.mjs +315 -0
- package/package.json +19 -4
package/README.md
CHANGED
|
@@ -1,3 +1,30 @@
|
|
|
1
|
-
#
|
|
1
|
+
# graphrt-plugin (JavaScript / TypeScript)
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
Write graphrt node kinds and tools for Node.js 18+. No dependencies; ships ESM
|
|
4
|
+
with TypeScript declarations.
|
|
5
|
+
|
|
6
|
+
```js
|
|
7
|
+
import { Plugin, PluginError, pause } from "graphrt-plugin";
|
|
8
|
+
|
|
9
|
+
const plugin = new Plugin("acme")
|
|
10
|
+
.node("acme.upper", async (ctx, req) => {
|
|
11
|
+
const text = String(req.config.text ?? "");
|
|
12
|
+
ctx.chunk("text", text.toUpperCase());
|
|
13
|
+
return { outputs: { text: text.toUpperCase() } };
|
|
14
|
+
})
|
|
15
|
+
.node("acme.approve", async (ctx, req) => {
|
|
16
|
+
if (!req.resume) return pause("approval", { message: "Publish?" }, { draft: req.config.text });
|
|
17
|
+
return { outputs: { approved: req.resume.input === "yes" }, branch: req.resume.input === "yes" ? "approved" : "rejected" };
|
|
18
|
+
})
|
|
19
|
+
.tool({ name: "shout", description: "Uppercase a text" }, async (args) => String(args.text).toUpperCase());
|
|
20
|
+
|
|
21
|
+
plugin.run();
|
|
22
|
+
```
|
|
23
|
+
|
|
24
|
+
Pair it with a `graphrt-plugin.json` manifest; see `docs/plugins.md`.
|
|
25
|
+
|
|
26
|
+
- `req.config`: node config with variables resolved by the host.
|
|
27
|
+
- `req.resume`: `{state, input}` after a pause, else `null`.
|
|
28
|
+
- `ctx.chunk(field, text)`, `ctx.progress(name, data)`, `ctx.log(message)`.
|
|
29
|
+
- `ctx.signal` aborts when the host cancels the request.
|
|
30
|
+
- Never `console.log` (stdout carries the protocol); use `console.error`.
|
package/index.d.ts
ADDED
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
/** Protocol version implemented by this SDK. */
|
|
2
|
+
export declare const PROTOCOL_VERSION: 1;
|
|
3
|
+
/** Default line limit; the host announces its own in `initialize`. */
|
|
4
|
+
export declare const MAX_MESSAGE_BYTES: number;
|
|
5
|
+
|
|
6
|
+
/** Error reported to the host as a failed node. */
|
|
7
|
+
export declare class PluginError extends Error {
|
|
8
|
+
constructor(message: string, options?: { kind?: string; retryable?: boolean; retryAfterMs?: number });
|
|
9
|
+
kind: string;
|
|
10
|
+
retryable: boolean;
|
|
11
|
+
retryAfterMs?: number;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
export interface Resume {
|
|
15
|
+
/** State returned with `pause(...)`. */
|
|
16
|
+
state: unknown;
|
|
17
|
+
/** Host-supplied input (e.g. a submitted form), or null. */
|
|
18
|
+
input: unknown;
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
export interface RunRequest {
|
|
22
|
+
requestId: string;
|
|
23
|
+
kind: string;
|
|
24
|
+
nodeId: string;
|
|
25
|
+
attempt: number;
|
|
26
|
+
/** Node config with variables resolved by the host. */
|
|
27
|
+
config: Record<string, any>;
|
|
28
|
+
resume: Resume | null;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export interface RunResult {
|
|
32
|
+
outputs: Record<string, unknown>;
|
|
33
|
+
branch?: string | null;
|
|
34
|
+
writes?: Array<{ selector: string[] | string; value: unknown }>;
|
|
35
|
+
usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
|
|
36
|
+
metadata?: Record<string, unknown>;
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
export interface PauseResult {
|
|
40
|
+
pause: { kind: string; data: unknown; state: unknown };
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
export declare function pause(kind: string, data?: unknown, state?: unknown): PauseResult;
|
|
44
|
+
|
|
45
|
+
export declare class RunContext {
|
|
46
|
+
readonly requestId: string;
|
|
47
|
+
/** Stream text for output `field`. */
|
|
48
|
+
chunk(field: string, text: string): void;
|
|
49
|
+
/** Report structured progress. */
|
|
50
|
+
progress(name: string, data?: unknown): void;
|
|
51
|
+
/** Send a log line to the host. */
|
|
52
|
+
log(message: string, level?: "debug" | "info" | "warn" | "error"): void;
|
|
53
|
+
/** Fired when the host cancels this request. */
|
|
54
|
+
readonly signal: AbortSignal;
|
|
55
|
+
readonly cancelled: boolean;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
export interface ToolSpec {
|
|
59
|
+
name: string;
|
|
60
|
+
description?: string;
|
|
61
|
+
parameters?: Record<string, unknown>;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
export type ToolResult = string | { text: string; data?: unknown; is_error?: boolean };
|
|
65
|
+
|
|
66
|
+
export type NodeHandler = (
|
|
67
|
+
ctx: RunContext,
|
|
68
|
+
req: RunRequest,
|
|
69
|
+
) => RunResult | PauseResult | Record<string, unknown> | void | Promise<RunResult | PauseResult | Record<string, unknown> | void>;
|
|
70
|
+
|
|
71
|
+
export declare class Plugin {
|
|
72
|
+
constructor(name: string);
|
|
73
|
+
readonly name: string;
|
|
74
|
+
node(kind: string, handler: NodeHandler, descriptor?: Record<string, unknown>): this;
|
|
75
|
+
tool(spec: ToolSpec, handler: (args: Record<string, any>) => ToolResult | Promise<ToolResult>): this;
|
|
76
|
+
run(options?: { input?: NodeJS.ReadableStream; output?: NodeJS.WritableStream }): Promise<void>;
|
|
77
|
+
}
|
package/index.mjs
ADDED
|
@@ -0,0 +1,315 @@
|
|
|
1
|
+
// graphrt plugin SDK for JavaScript / TypeScript (Node.js >= 18, no dependencies).
|
|
2
|
+
//
|
|
3
|
+
// The plugin speaks newline-delimited JSON-RPC 2.0 over stdin/stdout.
|
|
4
|
+
// Never write to stdout yourself (console.log); use ctx.log() or console.error().
|
|
5
|
+
|
|
6
|
+
import { createInterface } from "node:readline";
|
|
7
|
+
|
|
8
|
+
export const PROTOCOL_VERSION = 1;
|
|
9
|
+
|
|
10
|
+
/** Error reported to the host as a failed node. */
|
|
11
|
+
export class PluginError extends Error {
|
|
12
|
+
/**
|
|
13
|
+
* @param {string} message
|
|
14
|
+
* @param {{kind?: string, retryable?: boolean, retryAfterMs?: number}} [options]
|
|
15
|
+
*/
|
|
16
|
+
constructor(message, options = {}) {
|
|
17
|
+
super(message);
|
|
18
|
+
this.name = "PluginError";
|
|
19
|
+
this.kind = options.kind ?? "plugin_error";
|
|
20
|
+
this.retryable = options.retryable ?? false;
|
|
21
|
+
this.retryAfterMs = options.retryAfterMs;
|
|
22
|
+
}
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
/** Build a result that pauses the run. */
|
|
26
|
+
export function pause(kind, data = null, state = null) {
|
|
27
|
+
return { pause: { kind, data, state } };
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
const RESULT_KEYS = new Set(["outputs", "branch", "writes", "usage", "metadata", "pause"]);
|
|
31
|
+
|
|
32
|
+
/** Default line limit; the host announces its own in `initialize` (`max_message_bytes`). */
|
|
33
|
+
export const MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
|
|
34
|
+
|
|
35
|
+
/** Best-effort request id from a line that could not be read. */
|
|
36
|
+
function recoverId(text) {
|
|
37
|
+
const match = /"id"\s*:\s*("(?:[^"\\]|\\.)*"|-?\d+)/.exec(text.slice(0, 4096));
|
|
38
|
+
if (!match) return null;
|
|
39
|
+
try {
|
|
40
|
+
return JSON.parse(match[1]);
|
|
41
|
+
} catch {
|
|
42
|
+
return null;
|
|
43
|
+
}
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
function normalizeResult(result) {
|
|
47
|
+
if (result === undefined || result === null) return { outputs: {} };
|
|
48
|
+
if (typeof result !== "object" || Array.isArray(result)) {
|
|
49
|
+
throw new PluginError("node handlers must return an object", { kind: "plugin_protocol" });
|
|
50
|
+
}
|
|
51
|
+
const keys = Object.keys(result);
|
|
52
|
+
if (keys.length > 0 && keys.every((k) => RESULT_KEYS.has(k))) return result;
|
|
53
|
+
return { outputs: result };
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
function errorData(e) {
|
|
57
|
+
if (e instanceof PluginError) {
|
|
58
|
+
const data = { kind: e.kind, retryable: e.retryable };
|
|
59
|
+
if (e.retryAfterMs !== undefined) data.retry_after_ms = e.retryAfterMs;
|
|
60
|
+
return data;
|
|
61
|
+
}
|
|
62
|
+
return { kind: "plugin_exception" };
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
/** Per-request helpers. */
|
|
66
|
+
export class RunContext {
|
|
67
|
+
constructor(plugin, requestId) {
|
|
68
|
+
this._plugin = plugin;
|
|
69
|
+
this.requestId = requestId;
|
|
70
|
+
this._controller = new AbortController();
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
/** Stream text for output `field`. */
|
|
74
|
+
chunk(field, text) {
|
|
75
|
+
this._plugin._notify("node.chunk", { request_id: this.requestId, field, chunk: String(text) });
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
/** Report structured progress. */
|
|
79
|
+
progress(name, data = null) {
|
|
80
|
+
this._plugin._notify("node.progress", { request_id: this.requestId, name, data });
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
/** Send a log line to the host. */
|
|
84
|
+
log(message, level = "info") {
|
|
85
|
+
this._plugin._notify("log", { level, message: String(message) });
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
/** AbortSignal fired when the host cancels this request (pass it to fetch, timers...). */
|
|
89
|
+
get signal() {
|
|
90
|
+
return this._controller.signal;
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
get cancelled() {
|
|
94
|
+
return this._controller.signal.aborted;
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
/** A set of node kinds and tools served over the graphrt plugin protocol. */
|
|
99
|
+
export class Plugin {
|
|
100
|
+
/** @param {string} name */
|
|
101
|
+
constructor(name) {
|
|
102
|
+
this.name = name;
|
|
103
|
+
this._nodes = new Map();
|
|
104
|
+
this._descriptors = [];
|
|
105
|
+
this._tools = new Map();
|
|
106
|
+
this._running = new Map();
|
|
107
|
+
this._maxMessageBytes = MAX_MESSAGE_BYTES;
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
/**
|
|
111
|
+
* Register a node handler `async (ctx, req) => result`.
|
|
112
|
+
* The result is `{outputs, branch?, writes?, usage?, metadata?}`, a plain object
|
|
113
|
+
* (taken as the outputs) or `pause(...)`. Throw `PluginError` to fail.
|
|
114
|
+
*/
|
|
115
|
+
node(kind, handler, descriptor) {
|
|
116
|
+
this._nodes.set(kind, handler);
|
|
117
|
+
if (descriptor) this._descriptors.push({ kind, ...descriptor });
|
|
118
|
+
return this;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
/** Register a tool `async (args) => string | {text, data?, is_error?}`. */
|
|
122
|
+
tool(spec, handler) {
|
|
123
|
+
this._tools.set(spec.name, { spec: { description: "", parameters: { type: "object" }, ...spec }, handler });
|
|
124
|
+
return this;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/** Serve on stdin/stdout until stdin closes or the host sends `shutdown`. */
|
|
128
|
+
run({ input = process.stdin, output = process.stdout } = {}) {
|
|
129
|
+
this._output = output;
|
|
130
|
+
// A stray rejection in user code must not silently kill the plugin process.
|
|
131
|
+
process.on("unhandledRejection", (reason) => {
|
|
132
|
+
console.error(`graphrt plugin ${this.name}: unhandled rejection:`, reason);
|
|
133
|
+
});
|
|
134
|
+
const rl = createInterface({ input, crlfDelay: Infinity, terminal: false });
|
|
135
|
+
return new Promise((resolve) => {
|
|
136
|
+
let shutdown = false;
|
|
137
|
+
const finish = () => {
|
|
138
|
+
// `shutdown` stops in-flight work; end of input lets it finish and reply.
|
|
139
|
+
if (shutdown) {
|
|
140
|
+
for (const entry of this._running.values()) {
|
|
141
|
+
entry.cancelled = true;
|
|
142
|
+
entry.ctx._controller.abort();
|
|
143
|
+
}
|
|
144
|
+
this._running.clear();
|
|
145
|
+
}
|
|
146
|
+
resolve();
|
|
147
|
+
};
|
|
148
|
+
rl.on("line", (line) => {
|
|
149
|
+
const text = line.trim();
|
|
150
|
+
if (!text) return;
|
|
151
|
+
if (Buffer.byteLength(text) > this._maxMessageBytes) {
|
|
152
|
+
console.error(`graphrt plugin ${this.name}: dropped a message above ${this._maxMessageBytes} bytes`);
|
|
153
|
+
this._error(recoverId(text), -32600, `message exceeds the ${this._maxMessageBytes}-byte limit`, { kind: "message_too_large" });
|
|
154
|
+
return;
|
|
155
|
+
}
|
|
156
|
+
let msg;
|
|
157
|
+
try {
|
|
158
|
+
msg = JSON.parse(text);
|
|
159
|
+
} catch {
|
|
160
|
+
console.error(`graphrt plugin ${this.name}: unreadable message`);
|
|
161
|
+
this._error(recoverId(text), -32700, "parse error", { kind: "plugin_protocol" });
|
|
162
|
+
return;
|
|
163
|
+
}
|
|
164
|
+
if (msg === null || typeof msg !== "object" || Array.isArray(msg)) {
|
|
165
|
+
this._error(null, -32600, "message must be a JSON object", { kind: "plugin_protocol" });
|
|
166
|
+
return;
|
|
167
|
+
}
|
|
168
|
+
if (!this._dispatch(msg)) {
|
|
169
|
+
shutdown = true;
|
|
170
|
+
rl.close();
|
|
171
|
+
}
|
|
172
|
+
});
|
|
173
|
+
rl.on("close", finish);
|
|
174
|
+
});
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
_dispatch(msg) {
|
|
178
|
+
const { id, method } = msg;
|
|
179
|
+
const params = msg.params ?? {};
|
|
180
|
+
if (method === "shutdown") return false;
|
|
181
|
+
if (id === undefined || id === null) {
|
|
182
|
+
if (method === "node.cancel") {
|
|
183
|
+
const entry = this._running.get(params.request_id);
|
|
184
|
+
if (entry) {
|
|
185
|
+
entry.ctx._controller.abort();
|
|
186
|
+
entry.cancelled = true;
|
|
187
|
+
this._running.delete(params.request_id);
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
return true;
|
|
191
|
+
}
|
|
192
|
+
switch (method) {
|
|
193
|
+
case "initialize": {
|
|
194
|
+
if (Number.isInteger(params.max_message_bytes) && params.max_message_bytes >= 1024) {
|
|
195
|
+
this._maxMessageBytes = params.max_message_bytes;
|
|
196
|
+
}
|
|
197
|
+
const result = { protocol_version: PROTOCOL_VERSION, name: this.name };
|
|
198
|
+
if (this._descriptors.length) result.nodes = this._descriptors;
|
|
199
|
+
if (this._tools.size) result.tools = [...this._tools.values()].map((t) => t.spec);
|
|
200
|
+
this._reply(id, result);
|
|
201
|
+
break;
|
|
202
|
+
}
|
|
203
|
+
case "node.run":
|
|
204
|
+
this._startRun(id, params);
|
|
205
|
+
break;
|
|
206
|
+
case "tool.list":
|
|
207
|
+
this._reply(id, { tools: [...this._tools.values()].map((t) => t.spec) });
|
|
208
|
+
break;
|
|
209
|
+
case "tool.call":
|
|
210
|
+
this._callTool(id, params);
|
|
211
|
+
break;
|
|
212
|
+
default:
|
|
213
|
+
this._error(id, -32601, `method \`${method}\` not found`);
|
|
214
|
+
}
|
|
215
|
+
return true;
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
_startRun(id, params) {
|
|
219
|
+
const kind = params.kind ?? "";
|
|
220
|
+
const handler = this._nodes.get(kind);
|
|
221
|
+
if (!handler) {
|
|
222
|
+
this._error(id, -32602, `plugin \`${this.name}\` has no node kind \`${kind}\``, { kind: "unknown_kind" });
|
|
223
|
+
return;
|
|
224
|
+
}
|
|
225
|
+
const requestId = String(params.request_id ?? id);
|
|
226
|
+
const resume = params.resume && typeof params.resume === "object"
|
|
227
|
+
? { state: params.resume.state ?? null, input: params.resume.input ?? null }
|
|
228
|
+
: null;
|
|
229
|
+
const req = {
|
|
230
|
+
requestId,
|
|
231
|
+
kind,
|
|
232
|
+
nodeId: params.node_id ?? "",
|
|
233
|
+
attempt: params.attempt ?? 1,
|
|
234
|
+
config: params.config ?? {},
|
|
235
|
+
resume,
|
|
236
|
+
};
|
|
237
|
+
const ctx = new RunContext(this, requestId);
|
|
238
|
+
const entry = { ctx, cancelled: false };
|
|
239
|
+
this._running.set(requestId, entry);
|
|
240
|
+
const run = async () => {
|
|
241
|
+
try {
|
|
242
|
+
const result = await handler(ctx, req);
|
|
243
|
+
// normalizeResult and encoding may throw too: handled below, never unhandled.
|
|
244
|
+
if (!entry.cancelled) this._reply(id, normalizeResult(result));
|
|
245
|
+
} catch (e) {
|
|
246
|
+
if (!(e instanceof PluginError)) console.error(e);
|
|
247
|
+
if (!entry.cancelled) this._error(id, -32000, e instanceof Error ? e.message : String(e), errorData(e));
|
|
248
|
+
} finally {
|
|
249
|
+
this._running.delete(requestId);
|
|
250
|
+
}
|
|
251
|
+
};
|
|
252
|
+
run().catch((e) => this._fatal(id, e));
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
_callTool(id, params) {
|
|
256
|
+
const run = async () => {
|
|
257
|
+
const tool = this._tools.get(params.name);
|
|
258
|
+
if (!tool) {
|
|
259
|
+
this._error(id, -32602, `plugin \`${this.name}\` has no tool \`${params.name}\``, { kind: "unknown_tool" });
|
|
260
|
+
return;
|
|
261
|
+
}
|
|
262
|
+
try {
|
|
263
|
+
let result = await tool.handler(params.arguments ?? {});
|
|
264
|
+
if (typeof result === "string") result = { text: result };
|
|
265
|
+
this._reply(id, { text: "", is_error: false, ...(result ?? {}) });
|
|
266
|
+
} catch (e) {
|
|
267
|
+
if (!(e instanceof PluginError)) console.error(e);
|
|
268
|
+
this._error(id, -32000, e instanceof Error ? e.message : String(e), errorData(e));
|
|
269
|
+
}
|
|
270
|
+
};
|
|
271
|
+
run().catch((e) => this._fatal(id, e));
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
/** Last resort when even an error reply failed: log and send a minimal error. */
|
|
275
|
+
_fatal(id, e) {
|
|
276
|
+
console.error(e);
|
|
277
|
+
try {
|
|
278
|
+
this._output.write(
|
|
279
|
+
JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32000, message: "plugin failed to encode its reply", data: { kind: "plugin_exception" } } }) + "\n",
|
|
280
|
+
);
|
|
281
|
+
} catch (inner) {
|
|
282
|
+
console.error(inner);
|
|
283
|
+
}
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
_send(msg) {
|
|
287
|
+
this._output.write(JSON.stringify(msg) + "\n");
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
_notify(method, params) {
|
|
291
|
+
try {
|
|
292
|
+
this._send({ jsonrpc: "2.0", method, params });
|
|
293
|
+
} catch (e) {
|
|
294
|
+
console.error(`graphrt plugin ${this.name}: dropped \`${method}\` notification:`, e);
|
|
295
|
+
}
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
_reply(id, result) {
|
|
299
|
+
let line;
|
|
300
|
+
try {
|
|
301
|
+
line = JSON.stringify({ jsonrpc: "2.0", id, result });
|
|
302
|
+
} catch (e) {
|
|
303
|
+
// BigInt, circular structures...: report instead of crashing the process.
|
|
304
|
+
this._error(id, -32000, `result is not valid JSON: ${e instanceof Error ? e.message : String(e)}`, { kind: "invalid_output" });
|
|
305
|
+
return;
|
|
306
|
+
}
|
|
307
|
+
this._output.write(line + "\n");
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
_error(id, code, message, data) {
|
|
311
|
+
const error = { code, message };
|
|
312
|
+
if (data !== undefined) error.data = data;
|
|
313
|
+
this._send({ jsonrpc: "2.0", id, error });
|
|
314
|
+
}
|
|
315
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,21 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "graphrt-plugin",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.1.0",
|
|
4
|
+
"description": "SDK for writing graphrt plugins in JavaScript / TypeScript (no dependencies)",
|
|
5
|
+
"license": "Apache-2.0",
|
|
6
|
+
"type": "module",
|
|
7
|
+
"main": "./index.mjs",
|
|
8
|
+
"types": "./index.d.ts",
|
|
9
|
+
"exports": {
|
|
10
|
+
".": {
|
|
11
|
+
"types": "./index.d.ts",
|
|
12
|
+
"import": "./index.mjs"
|
|
13
|
+
}
|
|
14
|
+
},
|
|
15
|
+
"files": ["index.mjs", "index.d.ts", "README.md"],
|
|
16
|
+
"engines": { "node": ">=18" },
|
|
17
|
+
"repository": {
|
|
18
|
+
"type": "git",
|
|
19
|
+
"url": "https://github.com/BimaPangestu28/graphrt"
|
|
20
|
+
}
|
|
21
|
+
}
|