@tomradex/files 0.0.0-stage → 0.17.1
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/LICENSE +204 -0
- package/dist/agent-index.d.ts +41 -0
- package/dist/channels.d.ts +90 -0
- package/dist/folder-store.d.ts +41 -0
- package/dist/git-backend.d.ts +29 -0
- package/dist/git-store.d.ts +205 -0
- package/dist/git-sync.d.ts +100 -0
- package/dist/index.d.ts +11 -0
- package/dist/mime.d.ts +6 -0
- package/dist/runtime.js +1 -0
- package/dist/scopes.d.ts +29 -0
- package/dist/service.d.ts +222 -0
- package/dist/store.d.ts +64 -0
- package/dist/tools.d.ts +9 -0
- package/dist/types.d.ts +334 -0
- package/dist/words.d.ts +22 -0
- package/package.json +46 -4
- package/README.md +0 -3
package/dist/types.d.ts
ADDED
|
@@ -0,0 +1,334 @@
|
|
|
1
|
+
import type { z } from "zod";
|
|
2
|
+
import type { FileReference } from "@tomradex/domain";
|
|
3
|
+
import type { ProviderConnection as FilesConnection } from "@tomradex/storage";
|
|
4
|
+
/** Where a project's files stand against what they are shared through. `local` means nothing beyond this machine to be in step with. */
|
|
5
|
+
export type FilesSyncState = "local" | "synced" | "ahead" | "behind" | "diverged" | "conflicted" | "syncing" | "offline" | "error" | "unavailable";
|
|
6
|
+
export interface FilesStatus {
|
|
7
|
+
state: FilesSyncState;
|
|
8
|
+
/** Non-secret: "github.com/acme/docs · main", or the folder. */
|
|
9
|
+
location: string | null;
|
|
10
|
+
detail?: string;
|
|
11
|
+
lastSyncAt: number | null;
|
|
12
|
+
conflicts: number;
|
|
13
|
+
ahead: number;
|
|
14
|
+
behind: number;
|
|
15
|
+
/** The latest version, null until something has been saved. */
|
|
16
|
+
head: string | null;
|
|
17
|
+
/** True for a store that keeps no versions — no git on this machine: no history, undo, ticket pins or sharing. */
|
|
18
|
+
versionless?: boolean;
|
|
19
|
+
}
|
|
20
|
+
export type FileChange = "added" | "modified" | "deleted" | "renamed" | "conflicted";
|
|
21
|
+
/** Sharing intent, independent of whether a remote is connected or reachable. */
|
|
22
|
+
export type SyncMode = "shared" | "local";
|
|
23
|
+
/** Whether Tomrade mentions a path to agents unasked. Never a permission: an unlisted path still reads and writes. */
|
|
24
|
+
export type ListMode = "listed" | "unlisted";
|
|
25
|
+
/** Closest ancestor wins; an exact rule overrides the parent. Paths are Files-relative. */
|
|
26
|
+
export interface PathPolicy<M extends string> {
|
|
27
|
+
default: M;
|
|
28
|
+
rules: Array<{
|
|
29
|
+
path: string;
|
|
30
|
+
mode: M;
|
|
31
|
+
}>;
|
|
32
|
+
}
|
|
33
|
+
export interface PathPreference<M extends string> {
|
|
34
|
+
mode: M;
|
|
35
|
+
source: "explicit" | "inherited" | "default";
|
|
36
|
+
sourcePath: string | null;
|
|
37
|
+
/** A folder contains descendants with a different effective setting. */
|
|
38
|
+
mixed: boolean;
|
|
39
|
+
}
|
|
40
|
+
export type FilesSyncPolicy = PathPolicy<SyncMode>;
|
|
41
|
+
export type FileSyncPreference = PathPreference<SyncMode>;
|
|
42
|
+
/**
|
|
43
|
+
* What the agent index and the browsing tools mention on their own. It governs
|
|
44
|
+
* disclosure, not access: reads and writes by path are never refused, and a
|
|
45
|
+
* path the person names in conversation or pins to a ticket always works.
|
|
46
|
+
*/
|
|
47
|
+
export type FilesAgentPolicy = PathPolicy<ListMode>;
|
|
48
|
+
export type FileListPreference = PathPreference<ListMode>;
|
|
49
|
+
export interface FileEntry {
|
|
50
|
+
/** Relative to the store root, forward slashes, no leading slash. */
|
|
51
|
+
path: string;
|
|
52
|
+
name: string;
|
|
53
|
+
kind: "file" | "dir";
|
|
54
|
+
size: number;
|
|
55
|
+
modifiedAt: number;
|
|
56
|
+
/** Stable across renames; null for folders and for files not yet saved as a version. */
|
|
57
|
+
fileId: string | null;
|
|
58
|
+
/** Pending against the latest version, when anything is. */
|
|
59
|
+
change?: FileChange;
|
|
60
|
+
/** Absent for backends that do not implement selective sharing. */
|
|
61
|
+
sync?: FileSyncPreference;
|
|
62
|
+
/** Absent for backends that do not implement the agent index. */
|
|
63
|
+
listing?: FileListPreference;
|
|
64
|
+
}
|
|
65
|
+
export interface FileContent {
|
|
66
|
+
path: string;
|
|
67
|
+
name: string;
|
|
68
|
+
fileId: string | null;
|
|
69
|
+
/** The version this content is from; null for a working copy that is not saved yet. */
|
|
70
|
+
versionId: string | null;
|
|
71
|
+
mime: string;
|
|
72
|
+
size: number;
|
|
73
|
+
encoding: "utf8" | "base64";
|
|
74
|
+
body: string;
|
|
75
|
+
/** Large bodies are cut short; `size` says how much there is. */
|
|
76
|
+
truncated: boolean;
|
|
77
|
+
/** sha-256 of the whole file, as `WriteOptions.expect` compares it. Absent where a backend cannot vouch for the bytes. */
|
|
78
|
+
hash?: string;
|
|
79
|
+
}
|
|
80
|
+
export interface FileVersion {
|
|
81
|
+
versionId: string;
|
|
82
|
+
at: number;
|
|
83
|
+
author: string;
|
|
84
|
+
message: string;
|
|
85
|
+
/** Where the file lived at this version. */
|
|
86
|
+
path: string;
|
|
87
|
+
}
|
|
88
|
+
export interface FileConflict {
|
|
89
|
+
path: string;
|
|
90
|
+
fileId: string | null;
|
|
91
|
+
/** Both sides changed it; both added it; one side deleted what the other edited. */
|
|
92
|
+
kind: "content" | "add-add" | "modify-delete" | "delete-modify";
|
|
93
|
+
binary: boolean;
|
|
94
|
+
/** Each side's text; null where that side has no file, or it is binary. */
|
|
95
|
+
ours: string | null;
|
|
96
|
+
theirs: string | null;
|
|
97
|
+
}
|
|
98
|
+
export type ConflictChoice = "ours" | "theirs" | "both";
|
|
99
|
+
export interface WriteOptions {
|
|
100
|
+
/** The version's message; a default names the path. */
|
|
101
|
+
message?: string;
|
|
102
|
+
/**
|
|
103
|
+
* The `hash` the writer last read: a file that no longer has it is left
|
|
104
|
+
* alone and the write throws `FileChangedError`. `null` means the path must
|
|
105
|
+
* be free. Omitted, the write lands whatever is there.
|
|
106
|
+
*/
|
|
107
|
+
expect?: string | null;
|
|
108
|
+
}
|
|
109
|
+
/** One file of a `writeMany`: every `expect` is checked before any byte lands. */
|
|
110
|
+
export interface WriteEntry {
|
|
111
|
+
path: string;
|
|
112
|
+
body: Buffer;
|
|
113
|
+
expect?: string | null;
|
|
114
|
+
}
|
|
115
|
+
/** A file a ticket body is about to link to, as the editor holds it until the body is saved. */
|
|
116
|
+
export interface AttachmentInput {
|
|
117
|
+
name: string;
|
|
118
|
+
base64: string;
|
|
119
|
+
}
|
|
120
|
+
/** What a guarded save got: the new version, or what is there now instead. */
|
|
121
|
+
export type SaveResult = {
|
|
122
|
+
ok: true;
|
|
123
|
+
content: FileContent;
|
|
124
|
+
} | {
|
|
125
|
+
ok: false;
|
|
126
|
+
current: FileContent | null;
|
|
127
|
+
};
|
|
128
|
+
/**
|
|
129
|
+
* The store contract every backend fulfils. Paths are relative and
|
|
130
|
+
* forward-slashed; a `{ fileId, versionId }` pair reads the same bytes for ever.
|
|
131
|
+
*/
|
|
132
|
+
export interface FileStore {
|
|
133
|
+
readonly dir: string;
|
|
134
|
+
/** One level of a folder; the root when `dir` is omitted. */
|
|
135
|
+
list(dir?: string): Promise<FileEntry[]>;
|
|
136
|
+
/** Every entry, depth first, folders before files. */
|
|
137
|
+
tree(): Promise<FileEntry[]>;
|
|
138
|
+
read(path: string): Promise<FileContent | null>;
|
|
139
|
+
readVersion(ref: FileReference): Promise<FileContent | null>;
|
|
140
|
+
/** The exact pair when that version holds that file, else null. */
|
|
141
|
+
resolveVersion(ref: FileReference): Promise<FileReference | null>;
|
|
142
|
+
/** Where a file is now, or null when it is gone. */
|
|
143
|
+
locate(fileId: string): Promise<string | null>;
|
|
144
|
+
history(path: string, limit?: number): Promise<FileVersion[]>;
|
|
145
|
+
write(path: string, body: Buffer, opts?: WriteOptions): Promise<FileContent>;
|
|
146
|
+
/** Several files as one version; refused whole when any `expect` fails. */
|
|
147
|
+
writeMany?(entries: WriteEntry[], opts?: {
|
|
148
|
+
message?: string;
|
|
149
|
+
}): Promise<void>;
|
|
150
|
+
mkdir(path: string): Promise<void>;
|
|
151
|
+
move(from: string, to: string, opts?: WriteOptions): Promise<void>;
|
|
152
|
+
/** Copy a file or folder to a new path, minted as a fresh id — never the source's. Refuses an existing destination. */
|
|
153
|
+
copy(from: string, to: string, opts?: WriteOptions): Promise<void>;
|
|
154
|
+
remove(path: string, opts?: WriteOptions): Promise<void>;
|
|
155
|
+
/** Save whatever changed outside the store — an editor, Finder — as a version. True when something was. */
|
|
156
|
+
settle(message?: string): Promise<boolean>;
|
|
157
|
+
/**
|
|
158
|
+
* The current version, or null before the first save. With `restore`, what
|
|
159
|
+
* makes an operation undoable: the service notes the version before and
|
|
160
|
+
* after it, and puts the touched paths back later.
|
|
161
|
+
*/
|
|
162
|
+
head?(): Promise<string | null>;
|
|
163
|
+
/**
|
|
164
|
+
* Put `paths` back as they were at version `to`, as a new version. Refused
|
|
165
|
+
* with `FileMovedOnError` when any of them differs from how version `from`
|
|
166
|
+
* left it — someone changed it since, and that change is not ours to lose.
|
|
167
|
+
* Returns the new version, or null when nothing needed to change.
|
|
168
|
+
*/
|
|
169
|
+
restore?(paths: string[], from: string, to: string, message: string): Promise<string | null>;
|
|
170
|
+
status(): Promise<FilesStatus>;
|
|
171
|
+
/** Local-only files retain the same local version and undo guarantees. */
|
|
172
|
+
syncPolicy?(): Promise<FilesSyncPolicy>;
|
|
173
|
+
/** Atomic batch. Empty path changes the root default; inherit removes an exception.
|
|
174
|
+
* Changing a folder rule preserves explicit descendant exceptions.
|
|
175
|
+
* This controls future sharing, not erasure of already published history.
|
|
176
|
+
*/
|
|
177
|
+
setSyncRules?(paths: string[], mode: SyncMode | "inherit"): Promise<FilesSyncPolicy>;
|
|
178
|
+
/** Which paths Tomrade names to agents unasked. Disclosure only; reads are never refused. */
|
|
179
|
+
agentPolicy?(): Promise<FilesAgentPolicy>;
|
|
180
|
+
/** Atomic batch, same shape as `setSyncRules`: empty path sets the root default, `inherit` drops an exception. */
|
|
181
|
+
setAgentRules?(paths: string[], mode: ListMode | "inherit"): Promise<FilesAgentPolicy>;
|
|
182
|
+
/** Literal or regular-expression search over the working copy. Absent when a backend cannot search. */
|
|
183
|
+
search?(input: FileSearchInput): Promise<FileSearchResult>;
|
|
184
|
+
/** Save, take the remote's changes, push. Conflicts are left for `conflicts()`/`resolve()`. */
|
|
185
|
+
sync(): Promise<FilesStatus>;
|
|
186
|
+
conflicts(): Promise<FileConflict[]>;
|
|
187
|
+
resolve(path: string, choice: ConflictChoice): Promise<void>;
|
|
188
|
+
close(): void;
|
|
189
|
+
}
|
|
190
|
+
export interface FileSearchInput {
|
|
191
|
+
/** Searched independently; each hit says which one it answered. */
|
|
192
|
+
queries: string[];
|
|
193
|
+
/** Limit to this folder (or file) of the store. */
|
|
194
|
+
path?: string;
|
|
195
|
+
/** Glob over the path's last segment, e.g. `*.md`. */
|
|
196
|
+
glob?: string;
|
|
197
|
+
/** Hits per query, across all files. */
|
|
198
|
+
max: number;
|
|
199
|
+
/** Treat each query as a regular expression instead of a literal string. */
|
|
200
|
+
regex?: boolean;
|
|
201
|
+
caseSensitive?: boolean;
|
|
202
|
+
}
|
|
203
|
+
export interface FileSearchHit {
|
|
204
|
+
query: string;
|
|
205
|
+
path: string;
|
|
206
|
+
line: number;
|
|
207
|
+
/** The matching line, clipped. */
|
|
208
|
+
text: string;
|
|
209
|
+
}
|
|
210
|
+
export interface FileSearchResult {
|
|
211
|
+
hits: FileSearchHit[];
|
|
212
|
+
/** Queries whose hits were cut off at `max`. */
|
|
213
|
+
truncated: string[];
|
|
214
|
+
}
|
|
215
|
+
/** An account behind a backend, the same shape as a storage provider's; the secret stays in the backend's own settings section. */
|
|
216
|
+
export type { ConnectionState, ProviderConnection as FilesConnection } from "@tomradex/storage";
|
|
217
|
+
export interface OpenStoreOptions<C> {
|
|
218
|
+
projectId: string;
|
|
219
|
+
/** This machine's copy, beside the project's own folder. */
|
|
220
|
+
dir: string;
|
|
221
|
+
/** The remote the project shares, or null for a store that lives here only. */
|
|
222
|
+
remote: C | null;
|
|
223
|
+
/** Non-fatal trouble goes here, prefixed by the caller. */
|
|
224
|
+
warn(message: string): void;
|
|
225
|
+
/** The store's files changed underneath the app: a sync, an outside edit. */
|
|
226
|
+
onChange(): void;
|
|
227
|
+
/** What the service was configured with; a backend takes what applies to it. */
|
|
228
|
+
env: StoreEnv;
|
|
229
|
+
/** The project's own repository, asked on every sync; a backend sharing through git keeps out of its root and the store's folder. */
|
|
230
|
+
projectRepository?(): Promise<ProjectRepository | null>;
|
|
231
|
+
}
|
|
232
|
+
/** The repository Tomrade drives for the project itself, with `.tomrade/` at its root. */
|
|
233
|
+
export interface ProjectRepository {
|
|
234
|
+
url: string;
|
|
235
|
+
branch: string;
|
|
236
|
+
/** The top-level folder its checkout keeps the files store in. */
|
|
237
|
+
folder: string;
|
|
238
|
+
}
|
|
239
|
+
export interface StoreEnv {
|
|
240
|
+
gitBinary: string;
|
|
241
|
+
watch: boolean;
|
|
242
|
+
settleMs: number;
|
|
243
|
+
pushMs: number;
|
|
244
|
+
}
|
|
245
|
+
/**
|
|
246
|
+
* A backend is a way of keeping a project's files: versions on this machine
|
|
247
|
+
* and, when configured, a remote every machine on the project shares. Its
|
|
248
|
+
* config is per project and travels with it, so it must hold no secret.
|
|
249
|
+
*/
|
|
250
|
+
export interface FilesBackend<C = unknown> {
|
|
251
|
+
/** Stable across releases: the project stores this id, not a package name. */
|
|
252
|
+
id: string;
|
|
253
|
+
title: string;
|
|
254
|
+
description?: string;
|
|
255
|
+
configSchema: z.ZodType<C>;
|
|
256
|
+
defaults: C;
|
|
257
|
+
/** The settings section holding this backend's credentials, if it needs any. */
|
|
258
|
+
settingsSection?: string;
|
|
259
|
+
connection?: FilesConnection;
|
|
260
|
+
open(opts: OpenStoreOptions<C>): Promise<FileStore> | FileStore;
|
|
261
|
+
/** Candidates the user picks from, so nothing has to be typed by hand. */
|
|
262
|
+
browse?(): Promise<{
|
|
263
|
+
label: string;
|
|
264
|
+
config: C;
|
|
265
|
+
}[]>;
|
|
266
|
+
/** A config for a remote that does not exist yet, from a name alone. */
|
|
267
|
+
draft?(name: string): Promise<C> | C;
|
|
268
|
+
/** One non-secret line naming the remote, for status. */
|
|
269
|
+
describe?(config: C): string;
|
|
270
|
+
/** The git repository a config shares through, so a remote that cannot work is refused before it is saved. */
|
|
271
|
+
repository?(config: C): Promise<{
|
|
272
|
+
url: string;
|
|
273
|
+
branch: string;
|
|
274
|
+
directory?: string;
|
|
275
|
+
}> | {
|
|
276
|
+
url: string;
|
|
277
|
+
branch: string;
|
|
278
|
+
directory?: string;
|
|
279
|
+
};
|
|
280
|
+
}
|
|
281
|
+
/** What the renderer gets: the schema as JSON Schema, so a form is drawn without the backend's code. */
|
|
282
|
+
export interface FilesBackendView {
|
|
283
|
+
id: string;
|
|
284
|
+
title: string;
|
|
285
|
+
description?: string;
|
|
286
|
+
schema: Record<string, unknown>;
|
|
287
|
+
defaults: unknown;
|
|
288
|
+
settingsSection?: string;
|
|
289
|
+
browsable: boolean;
|
|
290
|
+
creatable: boolean;
|
|
291
|
+
connection?: FilesConnection["prompt"];
|
|
292
|
+
}
|
|
293
|
+
export interface FilesInfo {
|
|
294
|
+
projectId: string;
|
|
295
|
+
/** This machine's copy, or null until the project has a folder. */
|
|
296
|
+
dir: string | null;
|
|
297
|
+
remote: {
|
|
298
|
+
backend: string;
|
|
299
|
+
config: Record<string, unknown>;
|
|
300
|
+
} | null;
|
|
301
|
+
status: FilesStatus;
|
|
302
|
+
}
|
|
303
|
+
export declare class UnknownBackendError extends Error {
|
|
304
|
+
readonly backendId: string;
|
|
305
|
+
constructor(backendId: string);
|
|
306
|
+
}
|
|
307
|
+
export declare class InvalidPathError extends Error {
|
|
308
|
+
readonly path: string;
|
|
309
|
+
constructor(path: string);
|
|
310
|
+
}
|
|
311
|
+
/** A path has changed since the operation being undone or redone; the restore is refused, not forced. */
|
|
312
|
+
export declare class FileMovedOnError extends Error {
|
|
313
|
+
readonly path: string;
|
|
314
|
+
constructor(path: string);
|
|
315
|
+
}
|
|
316
|
+
/** A guarded write found other bytes than the writer read: somebody saved in between. */
|
|
317
|
+
export declare class FileChangedError extends Error {
|
|
318
|
+
readonly path: string;
|
|
319
|
+
constructor(path: string);
|
|
320
|
+
}
|
|
321
|
+
/**
|
|
322
|
+
* The project's own checkout pulls whatever Files publishes there: at the root
|
|
323
|
+
* Files would take `.tomrade/`, and in the store's own folder two repositories
|
|
324
|
+
* would commit the same files, local-only ones included.
|
|
325
|
+
*/
|
|
326
|
+
export declare class ProjectRepositoryError extends Error {
|
|
327
|
+
readonly folder: string;
|
|
328
|
+
constructor(folder: string);
|
|
329
|
+
}
|
|
330
|
+
export declare class FilesUnavailableError extends Error {
|
|
331
|
+
readonly projectId: string;
|
|
332
|
+
constructor(projectId: string, reason: string);
|
|
333
|
+
}
|
|
334
|
+
//# sourceMappingURL=types.d.ts.map
|
package/dist/words.d.ts
ADDED
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
import type { FilesSyncState } from "./types.js";
|
|
2
|
+
/** The status bar's and the palette's words. */
|
|
3
|
+
export declare const FILES_WORDS: import("@tomradex/domain").WordBook<{
|
|
4
|
+
readonly conflicts: "Files · conflicts";
|
|
5
|
+
readonly offline: "Files · offline";
|
|
6
|
+
readonly error: "Files · error";
|
|
7
|
+
readonly sync: "Sync files now";
|
|
8
|
+
readonly group: "Files";
|
|
9
|
+
readonly openProject: "Open a project first";
|
|
10
|
+
readonly synced: "Files: {{state}}";
|
|
11
|
+
readonly syncedDetail: "Files: {{state}} — {{detail}}";
|
|
12
|
+
readonly stateSynced: "synced";
|
|
13
|
+
readonly stateConflicted: "conflicted";
|
|
14
|
+
readonly stateOffline: "offline";
|
|
15
|
+
readonly stateError: "error";
|
|
16
|
+
readonly noGit: "Versions, undo and attaching files to tickets need git, which is not installed on this computer";
|
|
17
|
+
readonly noGitShared: "Sharing these files, versions, undo and attaching files to tickets need git, which is not installed on this computer; the files stay in this folder until then";
|
|
18
|
+
readonly needsGit: "This needs git, which is not installed on this computer: install git to keep versions of files and attach them to tickets";
|
|
19
|
+
}>;
|
|
20
|
+
/** The states with a word of their own; any other is shown as it is. */
|
|
21
|
+
export declare const FILES_STATE_WORD: Partial<Record<FilesSyncState, "stateSynced" | "stateConflicted" | "stateOffline" | "stateError">>;
|
|
22
|
+
//# sourceMappingURL=words.d.ts.map
|
package/package.json
CHANGED
|
@@ -1,6 +1,48 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@tomradex/files",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.17.1",
|
|
4
|
+
"type": "module",
|
|
5
|
+
"author": "Haoyuan Tang",
|
|
6
|
+
"engines": {
|
|
7
|
+
"node": ">=22"
|
|
8
|
+
},
|
|
9
|
+
"publishConfig": {
|
|
10
|
+
"access": "public"
|
|
11
|
+
},
|
|
12
|
+
"license": "Apache-2.0",
|
|
13
|
+
"description": "ctx.files — the files a project keeps beside its backlog: a folder tree with versions, the backend registry, sync and conflicts, and the versioned references tickets pin as artifacts. Ships the git-backed store every remote backend builds on. — declarations for full-mode plugins; Tomrade provides the code at run time",
|
|
14
|
+
"keywords": [
|
|
15
|
+
"tomrade",
|
|
16
|
+
"tomrade-plugin",
|
|
17
|
+
"types"
|
|
18
|
+
],
|
|
19
|
+
"types": "./dist/index.d.ts",
|
|
20
|
+
"exports": {
|
|
21
|
+
".": {
|
|
22
|
+
"types": "./dist/index.d.ts",
|
|
23
|
+
"default": "./dist/runtime.js"
|
|
24
|
+
}
|
|
25
|
+
},
|
|
26
|
+
"files": [
|
|
27
|
+
"dist"
|
|
28
|
+
],
|
|
29
|
+
"dependencies": {
|
|
30
|
+
"@tomradex/agent": "0.17.1",
|
|
31
|
+
"@tomradex/boards": "0.17.1",
|
|
32
|
+
"@tomradex/contracts": "0.17.1",
|
|
33
|
+
"@tomradex/contributions": "0.17.1",
|
|
34
|
+
"@tomradex/db": "0.17.1",
|
|
35
|
+
"@tomradex/domain": "0.2.26",
|
|
36
|
+
"@tomradex/git": "0.17.1",
|
|
37
|
+
"@tomradex/hub": "0.17.1",
|
|
38
|
+
"@tomradex/ipc": "0.17.1",
|
|
39
|
+
"@tomradex/items": "0.17.1",
|
|
40
|
+
"@tomradex/oplog": "0.17.1",
|
|
41
|
+
"@tomradex/settings": "0.17.1",
|
|
42
|
+
"@tomradex/storage": "0.17.1",
|
|
43
|
+
"@tomradex/tools": "0.17.1",
|
|
44
|
+
"@tomradex/write": "0.17.1",
|
|
45
|
+
"cordis": "4.0.0-rc.8",
|
|
46
|
+
"zod": "^4.4.3"
|
|
47
|
+
}
|
|
48
|
+
}
|
package/README.md
DELETED