defuss-backplane 0.0.0-stage → 0.2.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/.env.example +3 -0
- package/ARCH.md +66 -0
- package/LICENSE +21 -0
- package/README.md +173 -2
- package/dist/THIRD-PARTY-LICENSES.txt +83 -0
- package/dist/cli.js +7303 -0
- package/dist/client.d.ts +172 -0
- package/dist/client.js +146 -0
- package/dist/config-itdy3nLB.js +42 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +4 -0
- package/package.json +56 -4
package/dist/client.d.ts
ADDED
|
@@ -0,0 +1,172 @@
|
|
|
1
|
+
import { PlanOptions, Page } from 'defuss-dataview/compute';
|
|
2
|
+
import { DataviewSorter } from 'defuss-dataview';
|
|
3
|
+
|
|
4
|
+
/** Local revisions are DBSONL commit receipts. Qualify a source receipt after restoring a backup. */
|
|
5
|
+
type RecordedRevision = number | {
|
|
6
|
+
storeId: string;
|
|
7
|
+
revision: number;
|
|
8
|
+
};
|
|
9
|
+
interface HistoryReadOptions {
|
|
10
|
+
$historic?: Date;
|
|
11
|
+
$asOfRevision?: RecordedRevision;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
type PrimaryKey = string | number | bigint;
|
|
15
|
+
/** IDs are stored with their type; 1, 1n and '1' address different documents. */
|
|
16
|
+
interface Document {
|
|
17
|
+
id: PrimaryKey;
|
|
18
|
+
}
|
|
19
|
+
/** The fields a collection opened with `$timestamps: true` maintains. */
|
|
20
|
+
type TimestampField = '_createdAt' | '_updatedAt';
|
|
21
|
+
declare const maintained: unique symbol;
|
|
22
|
+
type Stamped = {
|
|
23
|
+
readonly [maintained]: true;
|
|
24
|
+
};
|
|
25
|
+
type Written<T> = T extends Stamped ? TimestampField | typeof maintained : never;
|
|
26
|
+
type NewDocument<T extends Document> = string extends T['id'] ? Omit<T, 'id' | Written<T>> & {
|
|
27
|
+
id?: T['id'];
|
|
28
|
+
} : T extends Stamped ? Omit<T, Written<T>> : T;
|
|
29
|
+
interface FindRequest extends PlanOptions, Page, HistoryReadOptions {
|
|
30
|
+
sorters?: readonly DataviewSorter[];
|
|
31
|
+
/** 'scan' is useful for diagnostics and indexed-versus-scan equivalence tests. */
|
|
32
|
+
access?: 'auto' | 'scan';
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
interface Scope {
|
|
36
|
+
app: string;
|
|
37
|
+
tenant: string;
|
|
38
|
+
bucket: string;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
type Versioned<T> = {
|
|
42
|
+
found: false;
|
|
43
|
+
revision: null;
|
|
44
|
+
} | {
|
|
45
|
+
found: true;
|
|
46
|
+
value: T;
|
|
47
|
+
revision: string;
|
|
48
|
+
};
|
|
49
|
+
interface WriteOptions {
|
|
50
|
+
ifRevision?: string | null;
|
|
51
|
+
}
|
|
52
|
+
interface CacheWriteOptions extends WriteOptions {
|
|
53
|
+
ttlMs?: number;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
type CacheResult = {
|
|
57
|
+
hit: false;
|
|
58
|
+
} | {
|
|
59
|
+
hit: true;
|
|
60
|
+
value: unknown;
|
|
61
|
+
};
|
|
62
|
+
|
|
63
|
+
type Row = Document & Record<string, unknown>;
|
|
64
|
+
type InputRow = Record<string, unknown> & {
|
|
65
|
+
id?: PrimaryKey;
|
|
66
|
+
};
|
|
67
|
+
type Query = Pick<FindRequest, "filters" | "sorters" | "offset" | "limit"> & {
|
|
68
|
+
projection?: string[];
|
|
69
|
+
};
|
|
70
|
+
|
|
71
|
+
type VfsObject = {
|
|
72
|
+
key: string;
|
|
73
|
+
size: number;
|
|
74
|
+
revision: string;
|
|
75
|
+
mtimeMs: number;
|
|
76
|
+
};
|
|
77
|
+
type Absent = {
|
|
78
|
+
found: false;
|
|
79
|
+
revision: null;
|
|
80
|
+
};
|
|
81
|
+
type VfsHead = Absent | ({
|
|
82
|
+
found: true;
|
|
83
|
+
} & VfsObject);
|
|
84
|
+
type VfsRead = Absent | ({
|
|
85
|
+
found: true;
|
|
86
|
+
value: Uint8Array;
|
|
87
|
+
} & VfsObject);
|
|
88
|
+
type VfsDownload = Absent | ({
|
|
89
|
+
found: true;
|
|
90
|
+
stream: ReadableStream<Uint8Array>;
|
|
91
|
+
} & VfsObject);
|
|
92
|
+
type VfsRange = {
|
|
93
|
+
offset?: number;
|
|
94
|
+
length?: number;
|
|
95
|
+
};
|
|
96
|
+
type VfsListRequest = {
|
|
97
|
+
prefix?: string;
|
|
98
|
+
after?: string | null;
|
|
99
|
+
limit?: number;
|
|
100
|
+
};
|
|
101
|
+
type VfsPage = {
|
|
102
|
+
objects: VfsObject[];
|
|
103
|
+
nextAfter: string | null;
|
|
104
|
+
};
|
|
105
|
+
|
|
106
|
+
/** VERIFIED: Public fault contract shared by the SDK and both transports. */
|
|
107
|
+
declare const statuses: {
|
|
108
|
+
readonly INVALID_ARGUMENT: 400;
|
|
109
|
+
readonly UNAUTHORIZED: 401;
|
|
110
|
+
readonly FORBIDDEN: 403;
|
|
111
|
+
readonly NOT_FOUND: 404;
|
|
112
|
+
readonly METHOD_NOT_ALLOWED: 405;
|
|
113
|
+
readonly ALREADY_EXISTS: 409;
|
|
114
|
+
readonly REVISION_CONFLICT: 409;
|
|
115
|
+
readonly PAYLOAD_TOO_LARGE: 413;
|
|
116
|
+
readonly DSON_REQUIRED: 422;
|
|
117
|
+
readonly BUSY: 503;
|
|
118
|
+
readonly STORAGE_ERROR: 500;
|
|
119
|
+
readonly COMMIT_UNCERTAIN: 500;
|
|
120
|
+
readonly INTERNAL_ERROR: 500;
|
|
121
|
+
};
|
|
122
|
+
type ErrorCode = keyof typeof statuses;
|
|
123
|
+
declare class BackplaneError extends Error {
|
|
124
|
+
readonly code: ErrorCode;
|
|
125
|
+
readonly status: number;
|
|
126
|
+
constructor(code: ErrorCode, message: string, status?: number);
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
/** Upload sources. An async iterable such as a Node.js file stream becomes a web stream before `fetch` sends it.
|
|
130
|
+
* VERIFIED by the packed consumer's type check: with the default DOM library, the stream from `Readable.toWeb` is not
|
|
131
|
+
* assignable to the global `ReadableStream`, while every Node.js readable is an async iterable. */
|
|
132
|
+
type UploadBody = ReadableStream<Uint8Array> | AsyncIterable<Uint8Array> | Blob | Uint8Array | string;
|
|
133
|
+
declare function connectBackplane(options: {
|
|
134
|
+
app: string;
|
|
135
|
+
apiKey?: string;
|
|
136
|
+
port?: number;
|
|
137
|
+
}): Promise<{
|
|
138
|
+
tenant(tenant: string): {
|
|
139
|
+
cache(bucket: string): {
|
|
140
|
+
get: (key: string) => Promise<CacheResult>;
|
|
141
|
+
getVersioned: (key: string) => Promise<Versioned<unknown>>;
|
|
142
|
+
set: (key: string, value: unknown, ttlMs?: number | CacheWriteOptions) => Promise<boolean>;
|
|
143
|
+
delete: (key: string, options?: WriteOptions) => Promise<boolean>;
|
|
144
|
+
};
|
|
145
|
+
db<T extends Document = Row>(bucket: string): {
|
|
146
|
+
get: (id: T["id"]) => Promise<T | null>;
|
|
147
|
+
getVersioned: (id: T["id"]) => Promise<Versioned<T>>;
|
|
148
|
+
insert: (doc: NewDocument<T>, options?: {
|
|
149
|
+
ifRevision?: null;
|
|
150
|
+
}) => Promise<T["id"]>;
|
|
151
|
+
update: (id: T["id"], patch: Partial<Omit<T, "id">>, options?: WriteOptions) => Promise<boolean>;
|
|
152
|
+
delete: (id: T["id"], options?: WriteOptions) => Promise<boolean>;
|
|
153
|
+
query: (request?: Query) => Promise<{
|
|
154
|
+
rows: Partial<T>[];
|
|
155
|
+
}>;
|
|
156
|
+
};
|
|
157
|
+
vfs(bucket: string): {
|
|
158
|
+
put: (key: string, data: string | Uint8Array, options?: WriteOptions) => Promise<VfsObject>;
|
|
159
|
+
get: (key: string, range?: VfsRange) => Promise<VfsRead>;
|
|
160
|
+
head: (key: string) => Promise<VfsHead>;
|
|
161
|
+
list: (request?: VfsListRequest) => Promise<VfsPage>;
|
|
162
|
+
delete: (key: string, options?: WriteOptions) => Promise<boolean>;
|
|
163
|
+
/** Streams `body` into one object, which replaces the previous one only after the last byte arrives. */
|
|
164
|
+
upload(key: string, body: UploadBody, options?: WriteOptions): Promise<VfsObject>;
|
|
165
|
+
/** Opens one object version as a byte stream. Read or cancel the stream to release it on the daemon. */
|
|
166
|
+
download(key: string): Promise<VfsDownload>;
|
|
167
|
+
};
|
|
168
|
+
};
|
|
169
|
+
}>;
|
|
170
|
+
|
|
171
|
+
export { BackplaneError, connectBackplane };
|
|
172
|
+
export type { CacheResult, CacheWriteOptions, ErrorCode, InputRow, Query, Row, Scope, UploadBody, Versioned, VfsDownload, VfsHead, VfsListRequest, VfsObject, VfsPage, VfsRange, VfsRead, WriteOptions };
|
package/dist/client.js
ADDED
|
@@ -0,0 +1,146 @@
|
|
|
1
|
+
import { DSON } from 'defuss-dson';
|
|
2
|
+
import { s as settings, B as BackplaneError, a as statuses } from './config-itdy3nLB.js';
|
|
3
|
+
import 'node:path';
|
|
4
|
+
|
|
5
|
+
function sendable(body) {
|
|
6
|
+
if (typeof body === "string" || body instanceof Uint8Array || body instanceof Blob || body instanceof ReadableStream)
|
|
7
|
+
return body;
|
|
8
|
+
const chunks = body[Symbol.asyncIterator]();
|
|
9
|
+
return new ReadableStream({
|
|
10
|
+
async pull(controller) {
|
|
11
|
+
const next = await chunks.next();
|
|
12
|
+
if (next.done) controller.close();
|
|
13
|
+
else controller.enqueue(next.value);
|
|
14
|
+
},
|
|
15
|
+
async cancel(reason) {
|
|
16
|
+
await chunks.return?.(reason);
|
|
17
|
+
}
|
|
18
|
+
});
|
|
19
|
+
}
|
|
20
|
+
async function connectBackplane(options) {
|
|
21
|
+
const { app } = options;
|
|
22
|
+
const { base, apiKey } = settings(options);
|
|
23
|
+
const headers = {
|
|
24
|
+
Authorization: "Bearer " + apiKey,
|
|
25
|
+
"Content-Type": "application/json"
|
|
26
|
+
};
|
|
27
|
+
async function failure(response) {
|
|
28
|
+
const body = await response.text();
|
|
29
|
+
let fault = {};
|
|
30
|
+
try {
|
|
31
|
+
fault = JSON.parse(body) ?? {};
|
|
32
|
+
} catch {
|
|
33
|
+
}
|
|
34
|
+
return new BackplaneError(
|
|
35
|
+
fault.code && Object.hasOwn(statuses, fault.code) ? fault.code : "INTERNAL_ERROR",
|
|
36
|
+
typeof fault.error === "string" ? fault.error : "Backplane HTTP " + response.status,
|
|
37
|
+
response.status
|
|
38
|
+
);
|
|
39
|
+
}
|
|
40
|
+
async function post(path, body) {
|
|
41
|
+
const response = await fetch(base + path, {
|
|
42
|
+
method: "POST",
|
|
43
|
+
headers,
|
|
44
|
+
body,
|
|
45
|
+
redirect: "error"
|
|
46
|
+
});
|
|
47
|
+
if (!response.ok) throw await failure(response);
|
|
48
|
+
return response;
|
|
49
|
+
}
|
|
50
|
+
const schema = await (await post("/rpc/schema")).json();
|
|
51
|
+
const methods = new Set(
|
|
52
|
+
schema.flatMap(
|
|
53
|
+
(m) => Object.keys(m.methods).map((k) => m.moduleName + "." + k)
|
|
54
|
+
)
|
|
55
|
+
);
|
|
56
|
+
function ensure(method) {
|
|
57
|
+
if (!methods.has(method))
|
|
58
|
+
throw new Error("Method missing from server schema");
|
|
59
|
+
}
|
|
60
|
+
async function call(className, methodName, args) {
|
|
61
|
+
ensure(className + "." + methodName);
|
|
62
|
+
const response = await post(
|
|
63
|
+
"/rpc",
|
|
64
|
+
DSON.stringify({ className, methodName, args })
|
|
65
|
+
);
|
|
66
|
+
return DSON.parse(await response.text());
|
|
67
|
+
}
|
|
68
|
+
return {
|
|
69
|
+
tenant(tenant) {
|
|
70
|
+
return {
|
|
71
|
+
cache(bucket) {
|
|
72
|
+
const scope = { app, tenant, bucket };
|
|
73
|
+
return {
|
|
74
|
+
get: (key) => call("cache", "get", [scope, key]),
|
|
75
|
+
getVersioned: (key) => call("cache", "getVersioned", [scope, key]),
|
|
76
|
+
set: (key, value, ttlMs) => call("cache", "set", [scope, key, value, ttlMs]),
|
|
77
|
+
delete: (key, options2) => call("cache", "delete", [scope, key, options2])
|
|
78
|
+
};
|
|
79
|
+
},
|
|
80
|
+
db(bucket) {
|
|
81
|
+
const scope = { app, tenant, bucket };
|
|
82
|
+
return {
|
|
83
|
+
get: (id) => call("db", "get", [scope, id]),
|
|
84
|
+
getVersioned: (id) => call("db", "getVersioned", [scope, id]),
|
|
85
|
+
insert: (doc, options2) => call("db", "insert", [scope, doc, options2]),
|
|
86
|
+
update: (id, patch, options2) => call("db", "update", [scope, id, patch, options2]),
|
|
87
|
+
delete: (id, options2) => call("db", "delete", [scope, id, options2]),
|
|
88
|
+
query: (request = {}) => call("db", "query", [scope, request])
|
|
89
|
+
};
|
|
90
|
+
},
|
|
91
|
+
vfs(bucket) {
|
|
92
|
+
const scope = { app, tenant, bucket };
|
|
93
|
+
const object = (key) => base + "/vfs/object?" + new URLSearchParams({ app, tenant, bucket, key });
|
|
94
|
+
return {
|
|
95
|
+
put: (key, data, options2) => call("vfs", "put", [scope, key, data, options2]),
|
|
96
|
+
get: (key, range) => call("vfs", "get", [scope, key, range]),
|
|
97
|
+
head: (key) => call("vfs", "head", [scope, key]),
|
|
98
|
+
list: (request = {}) => call("vfs", "list", [scope, request]),
|
|
99
|
+
delete: (key, options2) => call("vfs", "delete", [scope, key, options2]),
|
|
100
|
+
/** Streams `body` into one object, which replaces the previous one only after the last byte arrives. */
|
|
101
|
+
async upload(key, body, options2 = {}) {
|
|
102
|
+
ensure("vfs.put");
|
|
103
|
+
const condition = options2.ifRevision === null ? { "If-None-Match": "*" } : typeof options2.ifRevision === "string" ? { "If-Match": '"' + options2.ifRevision + '"' } : {};
|
|
104
|
+
const response = await fetch(object(key), {
|
|
105
|
+
method: "PUT",
|
|
106
|
+
headers: {
|
|
107
|
+
Authorization: headers.Authorization,
|
|
108
|
+
"Content-Type": "application/octet-stream",
|
|
109
|
+
...condition
|
|
110
|
+
},
|
|
111
|
+
body: sendable(body),
|
|
112
|
+
duplex: "half",
|
|
113
|
+
redirect: "error"
|
|
114
|
+
});
|
|
115
|
+
if (!response.ok) throw await failure(response);
|
|
116
|
+
return response.json();
|
|
117
|
+
},
|
|
118
|
+
/** Opens one object version as a byte stream. Read or cancel the stream to release it on the daemon. */
|
|
119
|
+
async download(key) {
|
|
120
|
+
ensure("vfs.get");
|
|
121
|
+
const response = await fetch(object(key), {
|
|
122
|
+
headers: { Authorization: headers.Authorization },
|
|
123
|
+
redirect: "error"
|
|
124
|
+
});
|
|
125
|
+
if (response.status === 404) {
|
|
126
|
+
await response.body?.cancel();
|
|
127
|
+
return { found: false, revision: null };
|
|
128
|
+
}
|
|
129
|
+
if (!response.ok || !response.body) throw await failure(response);
|
|
130
|
+
return {
|
|
131
|
+
found: true,
|
|
132
|
+
key,
|
|
133
|
+
size: Number(response.headers.get("content-length")),
|
|
134
|
+
revision: (response.headers.get("etag") ?? "").slice(1, -1),
|
|
135
|
+
mtimeMs: Number(response.headers.get("x-mtime-ms")),
|
|
136
|
+
stream: response.body
|
|
137
|
+
};
|
|
138
|
+
}
|
|
139
|
+
};
|
|
140
|
+
}
|
|
141
|
+
};
|
|
142
|
+
}
|
|
143
|
+
};
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
export { BackplaneError, connectBackplane };
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
import { resolve } from 'node:path';
|
|
2
|
+
|
|
3
|
+
const statuses = {
|
|
4
|
+
INVALID_ARGUMENT: 400,
|
|
5
|
+
UNAUTHORIZED: 401,
|
|
6
|
+
FORBIDDEN: 403,
|
|
7
|
+
NOT_FOUND: 404,
|
|
8
|
+
METHOD_NOT_ALLOWED: 405,
|
|
9
|
+
ALREADY_EXISTS: 409,
|
|
10
|
+
REVISION_CONFLICT: 409,
|
|
11
|
+
PAYLOAD_TOO_LARGE: 413,
|
|
12
|
+
DSON_REQUIRED: 422,
|
|
13
|
+
BUSY: 503,
|
|
14
|
+
STORAGE_ERROR: 500,
|
|
15
|
+
COMMIT_UNCERTAIN: 500,
|
|
16
|
+
INTERNAL_ERROR: 500
|
|
17
|
+
};
|
|
18
|
+
class BackplaneError extends Error {
|
|
19
|
+
constructor(code, message, status = statuses[code]) {
|
|
20
|
+
super(message);
|
|
21
|
+
this.code = code;
|
|
22
|
+
this.name = "BackplaneError";
|
|
23
|
+
this.status = status;
|
|
24
|
+
}
|
|
25
|
+
code;
|
|
26
|
+
status;
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
function settings(options = {}) {
|
|
30
|
+
const port = options.port ?? Number(process.env.PORT ?? 43127);
|
|
31
|
+
const apiKey = options.apiKey ?? process.env.API_KEY;
|
|
32
|
+
if (!apiKey || !/^[\x21-\x7e]+$/.test(apiKey))
|
|
33
|
+
throw new Error("API_KEY must contain printable ASCII without whitespace");
|
|
34
|
+
if (!Number.isInteger(port) || port < 1 || port > 65535)
|
|
35
|
+
throw new Error("PORT must be 1..65535");
|
|
36
|
+
return { port, apiKey, base: "http://127.0.0.1:" + port };
|
|
37
|
+
}
|
|
38
|
+
function dataRoot() {
|
|
39
|
+
return resolve(process.env.BACKPLANE_DATA_DIR || "./var/data");
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
export { BackplaneError as B, statuses as a, dataRoot as d, settings as s };
|
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
1
|
+
export { BackplaneError, CacheResult, CacheWriteOptions, ErrorCode, InputRow, Query, Row, Scope, UploadBody, Versioned, VfsDownload, VfsHead, VfsListRequest, VfsObject, VfsPage, VfsRange, VfsRead, WriteOptions, connectBackplane } from './client.js';
|
|
2
|
+
import 'defuss-dataview/compute';
|
|
3
|
+
import 'defuss-dataview';
|
package/dist/index.js
ADDED
package/package.json
CHANGED
|
@@ -1,6 +1,58 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "defuss-backplane",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.2.0",
|
|
4
|
+
"description": "Local, unified low-level persistence and logic layer RPC service for application service backend and MCP agents.",
|
|
5
|
+
"author": "Aron Homberg",
|
|
6
|
+
"license": "MIT",
|
|
7
|
+
"type": "module",
|
|
8
|
+
"packageManager": "bun@1.4.5",
|
|
9
|
+
"engines": {
|
|
10
|
+
"node": ">=26",
|
|
11
|
+
"bun": ">=1.4.4"
|
|
12
|
+
},
|
|
13
|
+
"exports": {
|
|
14
|
+
".": {
|
|
15
|
+
"types": "./dist/index.d.ts",
|
|
16
|
+
"import": "./dist/index.js"
|
|
17
|
+
},
|
|
18
|
+
"./client": {
|
|
19
|
+
"types": "./dist/client.d.ts",
|
|
20
|
+
"import": "./dist/client.js"
|
|
21
|
+
}
|
|
22
|
+
},
|
|
23
|
+
"bin": {
|
|
24
|
+
"defuss-backplane": "./dist/cli.js"
|
|
25
|
+
},
|
|
26
|
+
"files": [
|
|
27
|
+
"dist",
|
|
28
|
+
"README.md",
|
|
29
|
+
"ARCH.md",
|
|
30
|
+
"LICENSE",
|
|
31
|
+
".env.example"
|
|
32
|
+
],
|
|
33
|
+
"scripts": {
|
|
34
|
+
"build": "pkgroll --clean-dist --license=dist/THIRD-PARTY-LICENSES.txt",
|
|
35
|
+
"lint": "oxlint --deny-warnings src tests scripts && tsc --noEmit && tsc -p tests && tsc -p scripts",
|
|
36
|
+
"test": "bun test tests",
|
|
37
|
+
"start": "node dist/cli.js"
|
|
38
|
+
},
|
|
39
|
+
"dependencies": {
|
|
40
|
+
"defuss-brotli": "0.3.0",
|
|
41
|
+
"defuss-dataview": "0.10.0",
|
|
42
|
+
"defuss-dbsonl": "0.9.0",
|
|
43
|
+
"defuss-dson": "1.5.1",
|
|
44
|
+
"defuss-lexicalsearch": "0.4.0",
|
|
45
|
+
"defuss-mcp": "0.6.0",
|
|
46
|
+
"defuss-rpc": "3.0.0",
|
|
47
|
+
"defuss-vfs": "0.3.0"
|
|
48
|
+
},
|
|
49
|
+
"devDependencies": {
|
|
50
|
+
"@modelcontextprotocol/client": "2.4.0",
|
|
51
|
+
"@types/bun": "1.4.5",
|
|
52
|
+
"@types/node": "^26.0.0",
|
|
53
|
+
"defuss-db": "3.1.0",
|
|
54
|
+
"oxlint": "^1.0.0",
|
|
55
|
+
"pkgroll": "^2.0.0",
|
|
56
|
+
"typescript": "5.9.3"
|
|
57
|
+
}
|
|
58
|
+
}
|