@maycombhq/sdk 2.0.0-beta.3 → 2.0.0-beta.30
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/npm/core/ai-decisions.d.ts +373 -0
- package/npm/core/api.d.ts +15888 -3797
- package/npm/core/app-memory.d.ts +69 -0
- package/npm/core/assistant-actor.d.ts +28 -7
- package/npm/core/audit.d.ts +174 -0
- package/npm/core/canary.d.ts +369 -0
- package/npm/core/cancel.d.ts +20 -0
- package/npm/core/catalog.d.ts +220 -66
- package/npm/core/change-types-migrate.d.ts +14 -0
- package/npm/core/cite.d.ts +88 -6
- package/npm/core/contract-check.d.ts +276 -0
- package/npm/core/curated.d.ts +10 -0
- package/npm/core/decision-batches.d.ts +29 -0
- package/npm/core/declarable-routes.d.ts +52 -0
- package/npm/core/declared-links.d.ts +210 -0
- package/npm/core/eol.d.ts +5 -0
- package/npm/core/fact-paths.d.ts +14 -0
- package/npm/core/facts-callers.d.ts +23 -1
- package/npm/core/facts-carry.d.ts +8 -2
- package/npm/core/facts-deps.d.ts +85 -0
- package/npm/core/facts-join-prototype.d.ts +66 -4
- package/npm/core/facts-join-vendor.d.ts +67 -7
- package/npm/core/facts-join.d.ts +476 -2
- package/npm/core/facts-terms.d.ts +108 -0
- package/npm/core/facts.d.ts +155 -1
- package/npm/core/field-places.d.ts +109 -0
- package/npm/core/file-pool.d.ts +84 -0
- package/npm/core/fs.d.ts +205 -7
- package/npm/core/glob-plain.d.ts +34 -0
- package/npm/core/glob.d.ts +14 -0
- package/npm/core/hash-cache.d.ts +53 -0
- package/npm/core/host-questions.d.ts +273 -1
- package/npm/core/identity.d.ts +20 -8
- package/npm/core/index.d.ts +38 -0
- package/npm/core/initialisms.d.ts +62 -0
- package/npm/core/kept-files.d.ts +17 -0
- package/npm/core/light.d.ts +5 -0
- package/npm/core/link-candidates.d.ts +224 -0
- package/npm/core/link-evidence.d.ts +212 -0
- package/npm/core/log.d.ts +2 -0
- package/npm/core/manifest-edit.d.ts +83 -6
- package/npm/core/merge.d.ts +28 -0
- package/npm/core/metarepo.d.ts +26 -1
- package/npm/core/migrate.d.ts +3 -2
- package/npm/core/org-notes.d.ts +180 -0
- package/npm/core/orgpack-defaults.d.ts +30 -6
- package/npm/core/orgpack-load.d.ts +24 -0
- package/npm/core/paths.d.ts +23 -0
- package/npm/core/printer.d.ts +18 -0
- package/npm/core/process-trees.d.ts +109 -0
- package/npm/core/profile-migrate.d.ts +13 -0
- package/npm/core/question-order.d.ts +23 -0
- package/npm/core/question-owners.d.ts +57 -0
- package/npm/core/question-proposals.d.ts +77 -0
- package/npm/core/question-roles.d.ts +84 -0
- package/npm/core/questions.d.ts +123 -6
- package/npm/core/record-cache.d.ts +122 -2
- package/npm/core/repo-files.d.ts +66 -0
- package/npm/core/repo-reads.d.ts +44 -0
- package/npm/core/roles-migrate.d.ts +10 -0
- package/npm/core/run-log.d.ts +341 -0
- package/npm/core/runtime-migrate.d.ts +18 -0
- package/npm/core/schema/ai.d.ts +61 -13
- package/npm/core/schema/common.d.ts +32 -8
- package/npm/core/schema/component-type.d.ts +193 -0
- package/npm/core/schema/conventions.d.ts +80 -0
- package/npm/core/schema/dialect.d.ts +12 -12
- package/npm/core/schema/fact-corrections.d.ts +112 -2
- package/npm/core/schema/facts.d.ts +743 -23
- package/npm/core/schema/frameworks.d.ts +12 -12
- package/npm/core/schema/kinds.d.ts +230 -66
- package/npm/core/schema/orgpack.d.ts +248 -24
- package/npm/core/schema/question.d.ts +281 -5
- package/npm/core/schema/reading-rules.d.ts +51 -0
- package/npm/core/schema/repo-type.d.ts +20 -2
- package/npm/core/schema/review.d.ts +30 -9
- package/npm/core/schema/scan-verify.d.ts +77 -0
- package/npm/core/schema/version.d.ts +4 -1
- package/npm/core/schema/workspace.d.ts +29 -11
- package/npm/core/setup-edit.d.ts +107 -0
- package/npm/core/shared-maps.d.ts +146 -0
- package/npm/core/stack-helpers.d.ts +32 -0
- package/npm/core/version-order.d.ts +14 -0
- package/npm/fs-repo.d.ts +2 -1
- package/npm/index.js +14248 -6710
- package/npm/listing.d.ts +14 -0
- package/npm/sandbox.d.ts +2 -1
- package/package.json +1 -1
package/npm/core/fs.d.ts
CHANGED
|
@@ -5,40 +5,238 @@
|
|
|
5
5
|
* Windows a rename can fail for a moment while a virus scanner or indexer holds the file:
|
|
6
6
|
* it is retried a few times before giving up.
|
|
7
7
|
*/
|
|
8
|
-
export declare function writeFileAtomic(path: string, data: string | Uint8Array
|
|
9
|
-
|
|
8
|
+
export declare function writeFileAtomic(path: string, data: string | Uint8Array, o?: {
|
|
9
|
+
/**
|
|
10
|
+
* Told the size and time (ms, floored) of the file as written (beta.28.2: a writer keeps its
|
|
11
|
+
* parse by them): the temporary file's, taken on its handle before the rename (which keeps
|
|
12
|
+
* them), when the file has the same once renamed; not told when they differ (the file was
|
|
13
|
+
* changed meanwhile, or the system set another time on close). With them, the sha256 of the
|
|
14
|
+
* bytes written and `writtenAt`, the clock (ms) as the write began: a parse kept by them is
|
|
15
|
+
* checked by that hash while the file's time is within the timestamp's grain of `writtenAt`
|
|
16
|
+
* (record-cache.ts, `RACY_MS`).
|
|
17
|
+
*/
|
|
18
|
+
stat?: (s: {
|
|
19
|
+
size: number;
|
|
20
|
+
mtimeMs: number;
|
|
21
|
+
sha: string;
|
|
22
|
+
writtenAt: number;
|
|
23
|
+
}) => void;
|
|
24
|
+
/**
|
|
25
|
+
* Only the quick tries when the file is held (`HeldOptions`): a cache's write, which may
|
|
26
|
+
* fail at no cost, never waits the long wait.
|
|
27
|
+
*/
|
|
28
|
+
quick?: boolean;
|
|
29
|
+
}): Promise<void>;
|
|
30
|
+
/**
|
|
31
|
+
* Write a file unless it already holds exactly these bytes: then it is left alone, its time
|
|
32
|
+
* too, and false is returned (beta.28.5: a run that works out a file's content again never
|
|
33
|
+
* replaces the file with itself; on Windows each replacement is a chance to meet a program that
|
|
34
|
+
* holds the file, and a time that moved for nothing makes every reader of it read it again).
|
|
35
|
+
*/
|
|
36
|
+
export declare function writeFileIfDiffers(path: string, data: string): Promise<boolean>;
|
|
37
|
+
/**
|
|
38
|
+
* Copy a file the way `writeFileAtomic` writes one: to a temporary file beside the target, then
|
|
39
|
+
* renamed over it. The copy is made by the system (a copy-on-write clone where the file system
|
|
40
|
+
* has them, APFS, Btrfs or XFS; else a copy in the kernel), so the bytes never pass through
|
|
41
|
+
* JavaScript (beta.28.1: a 60-repo estate's build.json is 180 MB).
|
|
42
|
+
*/
|
|
43
|
+
export declare function copyFileAtomic(from: string, path: string): Promise<void>;
|
|
44
|
+
/** A file changed on disk between being read and being written back: nothing was written. */
|
|
45
|
+
export declare class FileChangedError extends Error {
|
|
46
|
+
readonly path: string;
|
|
47
|
+
constructor(path: string);
|
|
48
|
+
}
|
|
49
|
+
/**
|
|
50
|
+
* Write a file back only when it still holds what the change was made from (`before`, the text
|
|
51
|
+
* as read; undefined when it wasn't there), so an edit made meanwhile (another request, the CLI,
|
|
52
|
+
* an editor) is never overwritten: that throws FileChangedError instead.
|
|
53
|
+
*/
|
|
54
|
+
export declare function writeFileIfUnchanged(path: string, before: string | undefined, data: string): Promise<void>;
|
|
55
|
+
/**
|
|
56
|
+
* How long a write waits on Windows for a file another program holds (beta.28.5): the owner's
|
|
57
|
+
* run over forty repos ended on a raw EPERM after the 5 s there were, a file of the facts folder
|
|
58
|
+
* open in an editor or read by an assistant's session at that moment.
|
|
59
|
+
*/
|
|
60
|
+
export declare const HELD_WAIT_MS = 45000;
|
|
61
|
+
/**
|
|
62
|
+
* The wait once a file has stayed held in this process: a cause that doesn't go away (a
|
|
63
|
+
* read-only folder, a program that keeps the folder open) costs the long wait once, not once a
|
|
64
|
+
* file or once a repo of a run over forty.
|
|
65
|
+
*/
|
|
66
|
+
export declare const HELD_AGAIN_MS = 5000;
|
|
67
|
+
/**
|
|
68
|
+
* Tests' Windows: a rename and a removal that fail, a wait that takes no time, the platform,
|
|
69
|
+
* where the line that says a write is waiting goes (standard error by default), and the
|
|
70
|
+
* temporary file's removal.
|
|
71
|
+
*/
|
|
72
|
+
export declare const fsHooks: {
|
|
73
|
+
rename?: (from: string, to: string) => Promise<void>;
|
|
74
|
+
/** `removeHeld`'s removal. */
|
|
75
|
+
remove?: (path: string) => Promise<void>;
|
|
76
|
+
sleep?: (ms: number) => Promise<void>;
|
|
77
|
+
platform?: NodeJS.Platform;
|
|
78
|
+
say?: (line: string) => void;
|
|
79
|
+
/** The removal of a failed write's temporary file. */
|
|
80
|
+
rm?: (path: string) => Promise<void>;
|
|
81
|
+
};
|
|
82
|
+
/**
|
|
83
|
+
* A file stayed held by another program (Windows: open in an editor, read by an assistant's
|
|
84
|
+
* session, scanned) for the whole wait: nothing was written, the file is as it was, and the
|
|
85
|
+
* temporary file is removed. A run over several repos reports the repo and goes on.
|
|
86
|
+
*/
|
|
87
|
+
export declare class FileHeldError extends Error {
|
|
88
|
+
readonly path: string;
|
|
89
|
+
readonly waitedMs: number;
|
|
90
|
+
readonly cause?: unknown | undefined;
|
|
91
|
+
readonly code = "ATTICUS_FILE_HELD";
|
|
92
|
+
constructor(path: string, waitedMs: number, cause?: unknown | undefined);
|
|
93
|
+
}
|
|
94
|
+
/**
|
|
95
|
+
* Whether an error is the file system's (a file held, no room, no permission, too many open
|
|
96
|
+
* files: Node's system errors, which name the call that failed) rather than a bug. A run over
|
|
97
|
+
* several repos says such a repo is not applied and goes on; any other error is thrown on.
|
|
98
|
+
*/
|
|
99
|
+
export declare function isFileSystemError(e: unknown): boolean;
|
|
100
|
+
/** Tests: forget that a file stayed held. */
|
|
101
|
+
export declare function forgetHeld(): void;
|
|
102
|
+
/**
|
|
103
|
+
* The signal that ends a wait for a held file besides the job's own (`currentSignal`): a
|
|
104
|
+
* command run in a terminal sets its Ctrl+C here, and clears it when it ends.
|
|
105
|
+
*/
|
|
106
|
+
export declare function setHeldWaitSignal(signal: AbortSignal | undefined): void;
|
|
107
|
+
/** How a held file is waited for. */
|
|
108
|
+
export interface HeldOptions {
|
|
109
|
+
/**
|
|
110
|
+
* Only the quick tries (about 5 s), then the system's error, as before beta.28.5: a cache's
|
|
111
|
+
* write, which may fail at no cost, and a folder's rename.
|
|
112
|
+
*/
|
|
113
|
+
quick?: boolean;
|
|
114
|
+
/** Ends the wait too (CancelledError), besides the job's Stop and the terminal's Ctrl+C. */
|
|
115
|
+
signal?: AbortSignal;
|
|
116
|
+
/** The quick tries (9: about 5 s). */
|
|
117
|
+
tries?: number;
|
|
118
|
+
}
|
|
119
|
+
/**
|
|
120
|
+
* Remove the temporary files an earlier run left in `dir` for the files whose names start with
|
|
121
|
+
* `prefix` (a write whose temporary file could not be removed, or a process that was killed):
|
|
122
|
+
* those older than an hour, so a write in progress in another process is never touched. Says
|
|
123
|
+
* which it removed; a folder that can't be listed or a file that can't be removed is no error.
|
|
124
|
+
*/
|
|
125
|
+
export declare function sweepStaleTmp(dir: string, prefix: string): Promise<string[]>;
|
|
126
|
+
/**
|
|
127
|
+
* Rename, waiting for a held target as `retryHeld` says. The third argument is the options, or
|
|
128
|
+
* the number of quick tries (as before beta.28.5).
|
|
129
|
+
*/
|
|
130
|
+
export declare function renameRetrying(from: string, to: string, o?: HeldOptions | number): Promise<void>;
|
|
131
|
+
/**
|
|
132
|
+
* Remove a file, waiting for one another program holds as a write waits (beta.28.5, the
|
|
133
|
+
* review: a plain `rm` of a held file threw the system's EPERM and ended a run over forty
|
|
134
|
+
* repos, as the rename had). A file that isn't there is no error.
|
|
135
|
+
*/
|
|
136
|
+
export declare function removeHeld(path: string, o?: HeldOptions): Promise<void>;
|
|
10
137
|
export interface LockInfo {
|
|
11
138
|
pid: number;
|
|
12
139
|
host: string;
|
|
13
140
|
startedAt: string;
|
|
14
141
|
what: string;
|
|
142
|
+
/**
|
|
143
|
+
* ADR 0205 step 2: `caches` once its writer gave its result and is writing its local caches
|
|
144
|
+
* (`caching`): a lock left so by a process that stopped then was of a catalog written whole.
|
|
145
|
+
*/
|
|
146
|
+
phase?: "caches";
|
|
15
147
|
}
|
|
16
148
|
export declare class LockHeldError extends Error {
|
|
17
149
|
readonly held: LockInfo;
|
|
18
|
-
|
|
150
|
+
readonly file?: string | undefined;
|
|
151
|
+
constructor(held: LockInfo, file?: string | undefined);
|
|
19
152
|
}
|
|
20
153
|
/** Where a metarepo's locks live: .atticus/locks/, on this machine only (git-ignored). */
|
|
21
154
|
export declare const lockFileOf: (root: string, name: string) => string;
|
|
22
155
|
/** Read a lock: undefined when free; `stale` when its process is gone (it was cut short). */
|
|
23
|
-
export declare function readLock(root: string, name: string
|
|
156
|
+
export declare function readLock(root: string, name: string, o?: {
|
|
157
|
+
maxAgeMs?: number;
|
|
158
|
+
now?: () => Date;
|
|
159
|
+
}): Promise<(LockInfo & {
|
|
24
160
|
stale: boolean;
|
|
25
161
|
}) | undefined>;
|
|
162
|
+
/** The tests' fault (the property tests, ADR 0205): the process stops after its result. */
|
|
163
|
+
export declare const afterResultHooks: {
|
|
164
|
+
/**
|
|
165
|
+
* The next `runAfterResult` never runs its work: its writer's lock is left as a process that
|
|
166
|
+
* stopped there leaves it (held by no one here, so the next taker takes it over). Once.
|
|
167
|
+
*/
|
|
168
|
+
die?: boolean;
|
|
169
|
+
};
|
|
170
|
+
/**
|
|
171
|
+
* ADR 0205 step 2 (the owner's answer of 2026-11-19: "done" is shown while the caches are
|
|
172
|
+
* written under the lock): run `work` after the caller has given its result. The work must end
|
|
173
|
+
* by releasing the lock its writer holds (`under`: the metarepo and the lock's name). A later
|
|
174
|
+
* `acquireLock` of that lock in this process waits for it first, so the next writer here never
|
|
175
|
+
* meets that lock held; a taker of another lock doesn't wait. A failure is swallowed, since the
|
|
176
|
+
* work is only a cache's (a cache not written is no cache).
|
|
177
|
+
*/
|
|
178
|
+
export declare function runAfterResult(work: () => Promise<void>, under?: {
|
|
179
|
+
root: string;
|
|
180
|
+
name: string;
|
|
181
|
+
}): void;
|
|
182
|
+
/** How many `runAfterResult` works of this process haven't ended (the tests). */
|
|
183
|
+
export declare function afterResultPending(): number;
|
|
184
|
+
/**
|
|
185
|
+
* Wait for the `runAfterResult` works of this process: every one (a server closing, a command
|
|
186
|
+
* ending), or only those under one lock (its next taker).
|
|
187
|
+
*/
|
|
188
|
+
export declare function settleAfterResult(under?: {
|
|
189
|
+
root: string;
|
|
190
|
+
name: string;
|
|
191
|
+
}): Promise<void>;
|
|
26
192
|
/**
|
|
27
193
|
* Take a lock for a long write (a scan): one at a time per metarepo. A lock whose process is
|
|
28
194
|
* gone was cut short (a crash, a closed terminal); it is taken over and reported as
|
|
29
|
-
* `interrupted`, so the caller can say the last run didn't finish.
|
|
195
|
+
* `interrupted`, so the caller can say the last run didn't finish. A writer of this process
|
|
196
|
+
* still writing its caches after its result (`runAfterResult`) is waited for first.
|
|
30
197
|
*/
|
|
31
|
-
export declare function acquireLock(root: string, name: string, what: string, now?: () => Date
|
|
198
|
+
export declare function acquireLock(root: string, name: string, what: string, now?: () => Date,
|
|
199
|
+
/** A lock older than this is taken over (Windows reuses a dead process's PID). */
|
|
200
|
+
o?: {
|
|
201
|
+
maxAgeMs?: number;
|
|
202
|
+
}): Promise<{
|
|
32
203
|
release: () => Promise<void>;
|
|
204
|
+
/** ADR 0205 step 2: the result is given; the caches are written next, under this lock. */
|
|
205
|
+
caching: () => Promise<void>;
|
|
33
206
|
interrupted?: LockInfo;
|
|
34
207
|
}>;
|
|
208
|
+
/** The lock file beside a file two processes write (`<file>.lock`): no facts-folder reader takes it for a file of its own. */
|
|
209
|
+
export declare const sharedLockFileOf: (path: string) => string;
|
|
210
|
+
/**
|
|
211
|
+
* Review of beta.23: the options of a lock that guards only a quick write (a stage's loop file,
|
|
212
|
+
* its thread, the stories' numbers): older than two minutes, it is stale whoever holds it.
|
|
213
|
+
*/
|
|
214
|
+
export declare const QUICK_WRITE_LOCK: {
|
|
215
|
+
readonly maxAgeMs: 120000;
|
|
216
|
+
};
|
|
217
|
+
/**
|
|
218
|
+
* Review round 46: run `work` holding a file that another process may append to or rewrite at
|
|
219
|
+
* the same time (a repo's corrections: the app server appends, a CLI command rewrites it), so a
|
|
220
|
+
* read, change and write never loses what the other wrote meanwhile. In this process the writers
|
|
221
|
+
* of one file queue; between processes `<file>.lock` is created with `wx` (which fails when it is
|
|
222
|
+
* there), retried with a short backoff. A lock whose process is gone, or older than `staleMs`, is
|
|
223
|
+
* taken over; after `waitMs` it gives up with LockHeldError naming the holder. No `flock`, so it
|
|
224
|
+
* works the same on Windows, where a lock file being deleted can refuse for a moment (EPERM,
|
|
225
|
+
* EBUSY): those are retried.
|
|
226
|
+
*/
|
|
227
|
+
export declare function withSharedFileLock<T>(path: string, work: () => Promise<T>, o?: {
|
|
228
|
+
staleMs?: number;
|
|
229
|
+
waitMs?: number;
|
|
230
|
+
what?: string;
|
|
231
|
+
maxAgeMs?: number;
|
|
232
|
+
}): Promise<T>;
|
|
35
233
|
/**
|
|
36
234
|
* What stays on this machine inside .atticus/: the person's settings, the log, locks, upgrade
|
|
37
235
|
* backups, the prompt and response history (ADR 0110), what `atticus probe` measured of the
|
|
38
236
|
* person's assistant (ADR 0124 addendum A-probe) and the parses kept between runs
|
|
39
237
|
* (`cache/`, record-cache.ts).
|
|
40
238
|
*/
|
|
41
|
-
export declare const LOCAL_ONLY: readonly ["me.yaml", "logs/", "locks/", "backups/", "history/", "probe/", "cache/"];
|
|
239
|
+
export declare const LOCAL_ONLY: readonly ["me.yaml", "logs/", "locks/", "backups/", "history/", "probe/", "cache/", "map-all/"];
|
|
42
240
|
/**
|
|
43
241
|
* Make sure .atticus/.gitignore keeps this machine's files out of Git. It lives inside
|
|
44
242
|
* .atticus/, so it works the same in a metarepo and in a repo adopted in place (where Atticus
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The .gitignore lines and path globs that need no automaton (the field report of
|
|
3
|
+
* 2.0.0-beta.28.3: a folder of clones took hours to read, each file of each clone matched
|
|
4
|
+
* against each of a few hundred .gitignore lines by an automaton that made a set a character).
|
|
5
|
+
* Most lines are a plain name, `*.ext` or `name*`: told by the path's own end or start. Used by
|
|
6
|
+
* `globMatcher` (glob.ts) and by the walker's rules (repo-files.ts); the automaton answers every
|
|
7
|
+
* other glob, and every path with a line end in it.
|
|
8
|
+
*/
|
|
9
|
+
/** A glob's text as written: trimmed, \ as /, a leading ./ dropped. */
|
|
10
|
+
export declare function tidy(glob: string): string;
|
|
11
|
+
/**
|
|
12
|
+
* A glob that is told by the path's own text, with no automaton: the whole path (`is`), the
|
|
13
|
+
* path or its end after a `/` (`name`: `node_modules` at any depth), the path's end (`suffix`:
|
|
14
|
+
* `*.class`), or the start of its last name (`prefix`: `npm-debug.log*`). True of paths with no
|
|
15
|
+
* line end in them (`hasLineEnd`), which the automaton's `**` never spans.
|
|
16
|
+
*/
|
|
17
|
+
export interface PlainGlob {
|
|
18
|
+
kind: "is" | "name" | "suffix" | "prefix";
|
|
19
|
+
text: string;
|
|
20
|
+
}
|
|
21
|
+
/** Whether a path has a line end in it: such a path is the automaton's, never a plain test's. */
|
|
22
|
+
export declare function hasLineEnd(path: string): boolean;
|
|
23
|
+
/** The plain test a glob comes to, as `globMatcher` reads it; undefined for any other glob. */
|
|
24
|
+
export declare function plainGlob(glob: string, anyDepth?: boolean): PlainGlob | undefined;
|
|
25
|
+
/** The same for a glob `globMatcher` has tidied already (its own text, its depth settled). */
|
|
26
|
+
export declare function plainOf(g: string, anyDepth: boolean): PlainGlob | undefined;
|
|
27
|
+
/** A plain glob's answer for a path with no line end in it. */
|
|
28
|
+
export declare function plainTest(g: PlainGlob, path: string): boolean;
|
|
29
|
+
/**
|
|
30
|
+
* The longest plain text every path a glob matches must hold (`_i.` of `*_i.[ch]`, `gen` of a
|
|
31
|
+
* line for any folder named gen): a path without it is no match, told before the automaton
|
|
32
|
+
* runs. The glob as `globMatcher` tidied it; "" when it has no plain text outside its `{a,b}`.
|
|
33
|
+
*/
|
|
34
|
+
export declare function neededText(g: string): string;
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Path globs for the code tools (grep `paths`, files, and every .gitignore line of a scanned
|
|
3
|
+
* repo), matched in linear time. A glob is compiled to a small automaton and run over the path
|
|
4
|
+
* one character at a time with a set of live states, so no glob, however its `*`s are laid out,
|
|
5
|
+
* can backtrack: these run on the main thread with no time limit (final review, 2.0.0-beta.21).
|
|
6
|
+
*/
|
|
7
|
+
export interface GlobMatcher {
|
|
8
|
+
test(path: string): boolean;
|
|
9
|
+
}
|
|
10
|
+
/**
|
|
11
|
+
* A glob as a matcher over a repo-relative path. A glob with no / matches a name at any depth;
|
|
12
|
+
* a leading / anchors it at the top.
|
|
13
|
+
*/
|
|
14
|
+
export declare function globMatcher(glob: string, anyDepth?: boolean): GlobMatcher;
|
|
@@ -0,0 +1,53 @@
|
|
|
1
|
+
import { type FileHash } from "./file-pool.js";
|
|
2
|
+
/**
|
|
3
|
+
* The text hashes of a folder's files, kept between runs (beta.28.5, the owner's field report of
|
|
4
|
+
* beta.28.4: every build spent 20 to 34 s "reading the catalog's files to check the build" on a
|
|
5
|
+
* Windows laptop with antivirus, 12,832 record files opened and hashed by each command of a run
|
|
6
|
+
* of forty, although none had changed; an open is what such a machine makes slow, a stat is not).
|
|
7
|
+
*
|
|
8
|
+
* Each file's hash (`textShaOf`, what `hashFilesIn` gives) is kept in
|
|
9
|
+
* `<cacheRoot>/.atticus/cache/`, by the file's path, size and modification time, under the rule
|
|
10
|
+
* the kept parses go by (record-cache.ts, ADR 0119 with its addendum, Git's "racily clean"):
|
|
11
|
+
*
|
|
12
|
+
* - a file whose size, time, change time or identity (its inode, NTFS's file id; not compared
|
|
13
|
+
* where the platform reports none) is another than the one its hash was kept by is read
|
|
14
|
+
* and hashed. The change time (ctime) is the system's own record of the last change to the
|
|
15
|
+
* file's bytes or its times, and no program sets it: an edit that puts the file's time back
|
|
16
|
+
* (a copy that keeps times, a restore) still moves it, which size and time alone would miss;
|
|
17
|
+
* - so is a file whose time or change time is within `RACY_MS` of the moment its hash was kept
|
|
18
|
+
* (a same-size edit within the timestamp's grain could keep them), until a later read finds
|
|
19
|
+
* it older;
|
|
20
|
+
* - any other file is not opened: any edit after its hash was kept has a later change time.
|
|
21
|
+
*
|
|
22
|
+
* So a hand edit of a record file is seen as it was before (the build's guards compare these
|
|
23
|
+
* hashes with build.json's), a same-size edit included, and a run with nothing changed costs a
|
|
24
|
+
* stat per file. The cache is derived, local to this machine and never committed; one that can't
|
|
25
|
+
* be read costs the hashes, one that can't be written costs the next run's. A read that names no
|
|
26
|
+
* `cacheRoot` keeps nothing and writes nothing (ADR 0038), and one with `keep: false` (a
|
|
27
|
+
* preview) reads what is kept and writes nothing.
|
|
28
|
+
*/
|
|
29
|
+
/**
|
|
30
|
+
* Tests hear how many files each call opened and hashed; with `off`, every file is read and
|
|
31
|
+
* hashed and nothing is kept, as before there were kept hashes (an equivalence test's other side).
|
|
32
|
+
*/
|
|
33
|
+
export declare const hashCacheHooks: {
|
|
34
|
+
onHashed?: (files: number) => void;
|
|
35
|
+
off?: boolean;
|
|
36
|
+
};
|
|
37
|
+
/**
|
|
38
|
+
* Every named file under `dir` with its text hash, size and time, in the order of `files`, as
|
|
39
|
+
* `hashFilesIn` gives them: from the hashes kept under `cacheRoot` for the files that haven't
|
|
40
|
+
* changed since, from the files for the rest. A file that can't be opened fails the call, as
|
|
41
|
+
* there (ENOENT for one gone since it was listed).
|
|
42
|
+
*/
|
|
43
|
+
export declare function hashFilesKept(o: {
|
|
44
|
+
dir: string;
|
|
45
|
+
/** Relative to `dir`, with forward slashes. */
|
|
46
|
+
files: readonly string[];
|
|
47
|
+
/** The metarepo this run is working in; none: every file is hashed and nothing is kept. */
|
|
48
|
+
cacheRoot?: string;
|
|
49
|
+
/** False: the kept hashes are read and nothing is written (a preview). */
|
|
50
|
+
keep?: boolean;
|
|
51
|
+
/** A job's Stop: ends the read with CancelledError; nothing is kept of a stopped read. */
|
|
52
|
+
signal?: AbortSignal;
|
|
53
|
+
}): Promise<FileHash[]>;
|
|
@@ -1,3 +1,5 @@
|
|
|
1
|
+
import { type Document } from "yaml";
|
|
2
|
+
import { type LineChange } from "./manifest-edit.js";
|
|
1
3
|
/**
|
|
2
4
|
* Which repo answers on a host (ADR 0088): a scan or atticus estate join asks, as a question
|
|
3
5
|
* file (ADR 0078), for each host the estate's calls name that no repo lists in its `hosts`;
|
|
@@ -5,20 +7,290 @@
|
|
|
5
7
|
*/
|
|
6
8
|
/** The step that asks which repo answers on a host. */
|
|
7
9
|
export declare const HOSTS_STEP = "scan-hosts";
|
|
10
|
+
/**
|
|
11
|
+
* The step that asks which repo or system answers a call with no target (the scanner's
|
|
12
|
+
* TARGETS_STEP), and its group question's option that says the calls go to more than one place:
|
|
13
|
+
* named here so an answer's rule (ADR 0153) is checked where it is written.
|
|
14
|
+
*/
|
|
15
|
+
export declare const TARGETS_STEP_ID = "facts-targets";
|
|
16
|
+
export declare const TARGETS_SPLIT_LABEL = "Not all to one place";
|
|
17
|
+
/**
|
|
18
|
+
* ADR 0162 (F8): the option of a targets question that opens the picker of the whole estate (the
|
|
19
|
+
* manifest's repos, the profiles' systems, the teams). It names nothing: it is never an answer.
|
|
20
|
+
*/
|
|
21
|
+
export declare const TARGETS_ANOTHER_LABEL = "Another repo\u2026";
|
|
22
|
+
/**
|
|
23
|
+
* ADR 0162 (F8): the step that asks who owns a topic or queue the repo publishes to or listens on
|
|
24
|
+
* that no estate repo serves the other side of, and its option that opens the picker (a system of
|
|
25
|
+
* the profile, or a team): the answer adds the topic to that system's aliases, so the merge lands
|
|
26
|
+
* the publish or the listener on it, as a file change for review.
|
|
27
|
+
*/
|
|
28
|
+
export declare const TOPICS_STEP_ID = "facts-topics";
|
|
29
|
+
export declare const TOPICS_OUTSIDE_LABEL = "A topic owned by another team or vendor";
|
|
30
|
+
/** A topics question's words: what the repo does with the topic, and the topic. */
|
|
31
|
+
export declare const topicQuestionText: (topic: string, component: string, side: "publish" | "listen") => string;
|
|
32
|
+
/** The topic a topics question asks about, read back from its words. */
|
|
33
|
+
export declare function topicOfQuestion(q: {
|
|
34
|
+
question: string;
|
|
35
|
+
}): string | undefined;
|
|
36
|
+
/** The options that open the picker: they name nothing, so they are never an answer. */
|
|
37
|
+
export declare const PICKER_LABELS: ReadonlySet<string>;
|
|
8
38
|
/** The last option of a hosts question: no repo of the estate answers on it. */
|
|
9
39
|
export declare const HOSTS_NONE = "None of these";
|
|
40
|
+
/**
|
|
41
|
+
* The step `atticus estate join` asks which component a spec step's call-out reaches by (named
|
|
42
|
+
* here so the answer's rules below are checked where it is written; the CLI raises it).
|
|
43
|
+
*/
|
|
44
|
+
export declare const ESTATE_TARGETS_STEP_ID = "estate-targets";
|
|
45
|
+
/**
|
|
46
|
+
* Beta.24 review (answers made into boxes): the questions about where calls go, whose answer the
|
|
47
|
+
* join reads: hosts, targets (an ambiguous call or an unknown host's), topics and the estate's
|
|
48
|
+
* call-outs. Each takes Ignore, and none takes words that name nothing as a system.
|
|
49
|
+
*/
|
|
50
|
+
export declare const JOIN_STEPS: ReadonlySet<string>;
|
|
51
|
+
/**
|
|
52
|
+
* The option every join question has (beta.24 review): the calls it asks about aren't real calls
|
|
53
|
+
* (CI/CD, a test, a template), so the join leaves them, the same as "None of these", and never
|
|
54
|
+
* draws a box for them. Its words with a reason are `Ignore: <reason>`.
|
|
55
|
+
*/
|
|
56
|
+
export declare const JOIN_IGNORE_LABEL = "Ignore: not a real call (e.g. CI/CD, a test, a template)";
|
|
57
|
+
/** How an Ignore answer with a reason starts (the person's words follow it). */
|
|
58
|
+
export declare const IGNORE_PREFIX = "Ignore:";
|
|
59
|
+
/** The Ignore option, as a question file holds it. */
|
|
60
|
+
export declare const ignoreOption: () => {
|
|
61
|
+
label: string;
|
|
62
|
+
means: string;
|
|
63
|
+
changes: string;
|
|
64
|
+
};
|
|
65
|
+
/** Beta.25: the longest reason an Ignore keeps, as the local API takes it. */
|
|
66
|
+
export declare const IGNORE_REASON_MAX = 300;
|
|
67
|
+
/** An Ignore answer's words: `Ignore: <reason>`. */
|
|
68
|
+
export declare const ignoreText: (reason: string) => string;
|
|
69
|
+
/**
|
|
70
|
+
* Whether a question's answer is Ignore (beta.24 review), and its reason when one was given: the
|
|
71
|
+
* Ignore option, or words that start `Ignore:`. Undefined for any other answer, or none.
|
|
72
|
+
*/
|
|
73
|
+
export declare function ignoredAnswer(q: {
|
|
74
|
+
options: readonly {
|
|
75
|
+
label: string;
|
|
76
|
+
}[];
|
|
77
|
+
answer?: {
|
|
78
|
+
option?: number;
|
|
79
|
+
text?: string;
|
|
80
|
+
by: unknown;
|
|
81
|
+
} | undefined;
|
|
82
|
+
}): {
|
|
83
|
+
reason?: string;
|
|
84
|
+
} | undefined;
|
|
85
|
+
/** The longest name an outside system an answer adds may have. */
|
|
86
|
+
export declare const SYSTEM_NAME_MAX = 40;
|
|
87
|
+
/**
|
|
88
|
+
* Beta.25 (review of beta.24): whether a system's name reads as a sentence: by its words only,
|
|
89
|
+
* two or more of a sentence's small words ("ignore this, its cicd related"). Never by its marks:
|
|
90
|
+
* a real system's name may have a comma, a full stop or a `!` in it ("Northwind, Inc.", "Harbor
|
|
91
|
+
* Co."), and a profile holds what its people wrote.
|
|
92
|
+
*/
|
|
93
|
+
export declare function nameReadsAsSentence(name: string): boolean;
|
|
94
|
+
/**
|
|
95
|
+
* Beta.25 (review of beta.24): whether words read as a sentence rather than a name: a sentence's
|
|
96
|
+
* marks (a comma, a semicolon, `!`, `?`, a quote, or a full stop that ends a word: never the dots
|
|
97
|
+
* of a host), or two or more of a sentence's small words ("ignore this, its cicd related"). A name
|
|
98
|
+
* of any length in words ("Payments API Gateway North East") is a name, and so is one with a
|
|
99
|
+
* single small word in it ("IT Service Desk", "Plan A").
|
|
100
|
+
*/
|
|
101
|
+
export declare function readsAsSentence(words: string): boolean;
|
|
102
|
+
/**
|
|
103
|
+
* Why words can't be a new outside system's name (beta.24 review), or undefined when they can: a
|
|
104
|
+
* short name of letters, digits, spaces and dashes, at most 40 characters, that doesn't read as a
|
|
105
|
+
* sentence (`readsAsSentence`). Lenient for names: "IT Service Desk", "Plan A" and a five-word
|
|
106
|
+
* name are names.
|
|
107
|
+
*/
|
|
108
|
+
export declare function systemNameProblem(name: string): string | undefined;
|
|
109
|
+
/** The names Atticus knows a target by (`knownTargetNames`). */
|
|
110
|
+
export interface KnownTargets {
|
|
111
|
+
ids: Set<string>;
|
|
112
|
+
names: Set<string>;
|
|
113
|
+
/**
|
|
114
|
+
* Beta.25: the profiles' systems' names exactly, lower case, marks and all ("northwind, inc."),
|
|
115
|
+
* of those whose name isn't a sentence by its words (`nameReadsAsSentence`).
|
|
116
|
+
*/
|
|
117
|
+
systemNames?: Set<string>;
|
|
118
|
+
}
|
|
119
|
+
/**
|
|
120
|
+
* Beta.25: the names Atticus knows a target by, as `namesKnownTarget` reads them: `ids` the ids
|
|
121
|
+
* (repos, components, a system's id, alias or topic, teams) exactly, lower case; `names` those and
|
|
122
|
+
* the systems' names, each also as the id it slugs to; `systemNames` the systems' names exactly.
|
|
123
|
+
* Systems whose id is in `except` are left out (the boxes an answer's words made, which name
|
|
124
|
+
* nothing real).
|
|
125
|
+
*/
|
|
126
|
+
export declare function knownTargetNames(root: string, o?: {
|
|
127
|
+
except?: ReadonlySet<string>;
|
|
128
|
+
}): Promise<Required<KnownTargets>>;
|
|
129
|
+
/**
|
|
130
|
+
* Whether words name a target of `knownTargetNames`: a profile system's name exactly, case aside
|
|
131
|
+
* (beta.25: "Northwind, Inc." names the system so named, its marks and all); else case and spacing
|
|
132
|
+
* aside, or by the id they slug to; words that read as a sentence only when they are an id exactly
|
|
133
|
+
* (a sentence is never a system's name, even one an answer's words once wrote into a profile).
|
|
134
|
+
*/
|
|
135
|
+
export declare function namesKnown(known: KnownTargets, words: string): boolean;
|
|
136
|
+
/**
|
|
137
|
+
* Beta.24 review: whether words name a repo, component, system or team Atticus knows, as an
|
|
138
|
+
* answer about where calls go may: a repo of the manifests (its id, component or a module's
|
|
139
|
+
* component), a system of the profiles (its id, name, an alias or a topic), a team of roles.yaml,
|
|
140
|
+
* or a component a repo's facts name. Case and spacing aside, or by the id the words slug to.
|
|
141
|
+
* Beta.25: words that read as a sentence name only an id they are exactly, and the systems in
|
|
142
|
+
* `except` (the boxes an answer's words made) are none.
|
|
143
|
+
*/
|
|
144
|
+
export declare function namesKnownTarget(root: string, words: string, o?: {
|
|
145
|
+
except?: ReadonlySet<string>;
|
|
146
|
+
}): Promise<boolean>;
|
|
147
|
+
/**
|
|
148
|
+
* Beta.24 review: the refusal of words that name no repo, component or system as the answer of a
|
|
149
|
+
* question about where calls go, in a person's words: what to do instead.
|
|
150
|
+
*/
|
|
151
|
+
export declare const wordsNameNothing: (words: string) => string;
|
|
152
|
+
/**
|
|
153
|
+
* The options of a hosts question that say an outside system answers on the host (O1): another
|
|
154
|
+
* team's system (boundary internal, the first, the default) or a vendor's. The answer writes the
|
|
155
|
+
* system into the profile of the repo that asked, with the host as its alias, so the calls to
|
|
156
|
+
* the host go to it (F3: a declared system no estate repo belongs to is outside).
|
|
157
|
+
*/
|
|
158
|
+
export declare const HOSTS_OUTSIDE_INTERNAL = "An outside system (new): another team's";
|
|
159
|
+
export declare const HOSTS_OUTSIDE_VENDOR = "An outside system (new): a vendor";
|
|
160
|
+
/** The boundary an outside-system option of a hosts question gives its system, if it is one. */
|
|
161
|
+
export declare function outsideBoundaryOf(label: string | undefined): "internal" | "vendor" | undefined;
|
|
162
|
+
/** The system an outside-system answer adds for a host: its id and name, both from the host. */
|
|
163
|
+
export declare function outsideSystemOf(host: string): {
|
|
164
|
+
id: string;
|
|
165
|
+
name: string;
|
|
166
|
+
};
|
|
10
167
|
/** The question for a host, with its port when the calls name one: localhost:9966. */
|
|
11
168
|
export declare const hostQuestionText: (host: string) => string;
|
|
12
169
|
/** The host a hosts question asks about, read back from its words. */
|
|
13
170
|
export declare function hostOfQuestion(q: {
|
|
14
171
|
question: string;
|
|
15
172
|
}): string | undefined;
|
|
173
|
+
/**
|
|
174
|
+
* Beta.24 review: the host a targets question the join raised for a host nothing resolves asks
|
|
175
|
+
* about (a gateway's forwarding call whose target URL is a token, `@targetUrl@`): its words start
|
|
176
|
+
* as a hosts question's do, and may go on to say what to do next (`forwardHostQuestion`). A
|
|
177
|
+
* targets question asked of a call (`Which repo or system answers ...`) has none. Beta.25: the
|
|
178
|
+
* host up to the first `?` that ends the question, so a token with spaces in it (`{{ vendor_url
|
|
179
|
+
* }}`, as `forwardHostQuestion` writes it) is read back whole.
|
|
180
|
+
*/
|
|
181
|
+
export declare function joinHostOfQuestion(q: {
|
|
182
|
+
question: string;
|
|
183
|
+
}): string | undefined;
|
|
184
|
+
/**
|
|
185
|
+
* The outside system an answer to a join host question adds (beta.24 review): named by the host,
|
|
186
|
+
* or for a host still written as a token, by the token's name (`@targetVendorUrl@` →
|
|
187
|
+
* `targetVendorUrl`), never with the token's marks in its id.
|
|
188
|
+
*/
|
|
189
|
+
export declare function outsideSystemOfJoinHost(host: string): {
|
|
190
|
+
id: string;
|
|
191
|
+
name: string;
|
|
192
|
+
};
|
|
193
|
+
/**
|
|
194
|
+
* Beta.25 (review of beta.24): the one way every profile edit is written (an outside system, a
|
|
195
|
+
* system a person named, a box put right), so a preview shows only the lines that really change:
|
|
196
|
+
* no line folded (`lineWidth: 0`), flow collections padded as the file pads them (`[ a ]` or
|
|
197
|
+
* `[a]`), and each line the edit didn't change kept exactly as the file had it (the library pads
|
|
198
|
+
* a file's maps and lists alike, so a file that mixes `{ a: 1 }` with `[b]` keeps both). LF only;
|
|
199
|
+
* the caller writes it in the file's own line endings.
|
|
200
|
+
*/
|
|
201
|
+
export declare function profileText(doc: Document, before: string | undefined): string;
|
|
202
|
+
/**
|
|
203
|
+
* Beta.25 (review of beta.24): a profile edit Atticus doesn't make, said in a person's words (the
|
|
204
|
+
* local API answers 422): the file stays as it is, for a person to change by hand.
|
|
205
|
+
*/
|
|
206
|
+
export declare class ProfileEditError extends Error {
|
|
207
|
+
}
|
|
208
|
+
/**
|
|
209
|
+
* Put an outside system for a host into the profile whose repos.manifest.yaml lists the repo
|
|
210
|
+
* that asked (O1): its id and name from the host, the host as its alias, the boundary given
|
|
211
|
+
* (internal: another team's; vendor). The profile keeps its comments and order, and is made,
|
|
212
|
+
* with the platform's id as its name, when there is none. `added` is false when a system of the
|
|
213
|
+
* profiles already names the host. Throws when no manifest lists the repo, or the profile would
|
|
214
|
+
* not be valid (an id another system has).
|
|
215
|
+
*/
|
|
216
|
+
export declare function addOutsideSystem(root: string, repo: string, host: string, boundary: "internal" | "vendor"): Promise<{
|
|
217
|
+
id: string;
|
|
218
|
+
profile: string;
|
|
219
|
+
added: boolean;
|
|
220
|
+
}>;
|
|
221
|
+
/**
|
|
222
|
+
* ADR 0162 (F8): put a system a person named in a targets answer into the profile whose
|
|
223
|
+
* repos.manifest.yaml lists the repo that asked: a vendor (boundary vendor), or another team's
|
|
224
|
+
* system (boundary internal, owner the team's id from roles.yaml). Written as a file change in the
|
|
225
|
+
* metarepo, for review in the pull request, never to a shared system. `added` is false when a
|
|
226
|
+
* system of the profiles already has the id. Throws when no manifest lists the repo, or the
|
|
227
|
+
* profile would not be valid.
|
|
228
|
+
*/
|
|
229
|
+
export declare function addProfileSystem(root: string, repo: string, s: {
|
|
230
|
+
id: string;
|
|
231
|
+
name: string;
|
|
232
|
+
boundary: "internal" | "vendor";
|
|
233
|
+
owner?: string;
|
|
234
|
+
/**
|
|
235
|
+
* The topics and queues it owns (ADR 0162 amendment): written under `topics`, never
|
|
236
|
+
* `aliases`, with the profile at schema version 2.
|
|
237
|
+
*/
|
|
238
|
+
topics?: string[];
|
|
239
|
+
}, o?: {
|
|
240
|
+
preview?: boolean;
|
|
241
|
+
}): Promise<{
|
|
242
|
+
id: string;
|
|
243
|
+
profile: string;
|
|
244
|
+
added: boolean;
|
|
245
|
+
topics?: string[];
|
|
246
|
+
/** The lines a new system changes in the profile (as the write makes them). */
|
|
247
|
+
changes?: LineChange[];
|
|
248
|
+
/**
|
|
249
|
+
* Beta.25: for a new system, the file, the text it was read as (undefined: none yet) and the
|
|
250
|
+
* text written (or, previewed, to write), so a caller can write it with others, all or none.
|
|
251
|
+
*/
|
|
252
|
+
write?: {
|
|
253
|
+
file: string;
|
|
254
|
+
before: string | undefined;
|
|
255
|
+
after: string;
|
|
256
|
+
};
|
|
257
|
+
}>;
|
|
258
|
+
/**
|
|
259
|
+
* Beta.24 review: take a system out of the profile that has it, or (with `rename`) give it another
|
|
260
|
+
* id and name, keeping its other fields, the file's comments and its order (a comment above a
|
|
261
|
+
* system taken out stays, above the next). For a system an answer's words made (a box on Map ›
|
|
262
|
+
* Trust): written as a file change in the
|
|
263
|
+
* metarepo, for review in the pull request. `preview` writes nothing. Undefined when no profile
|
|
264
|
+
* has the system. Throws when the profile would not be valid (the new id another system has).
|
|
265
|
+
*/
|
|
266
|
+
export declare function editProfileSystem(root: string, id: string, o?: {
|
|
267
|
+
rename?: {
|
|
268
|
+
id: string;
|
|
269
|
+
name: string;
|
|
270
|
+
};
|
|
271
|
+
preview?: boolean;
|
|
272
|
+
}): Promise<{
|
|
273
|
+
profile: string;
|
|
274
|
+
changes: LineChange[];
|
|
275
|
+
written: boolean;
|
|
276
|
+
/** Beta.25: the file, the text it was read as and the text written (or to write). */
|
|
277
|
+
file: string;
|
|
278
|
+
before: string;
|
|
279
|
+
after: string;
|
|
280
|
+
} | undefined>;
|
|
16
281
|
/**
|
|
17
282
|
* Put a host under a repo's `hosts` in the repos.manifest.yaml that lists it, keeping the
|
|
18
283
|
* file's comments and order. `added` is false when the repo already lists it. Throws when no
|
|
19
284
|
* manifest lists the repo, or the host isn't one the manifest takes.
|
|
20
285
|
*/
|
|
21
|
-
export declare function addManifestHost(root: string, repo: string, host: string
|
|
286
|
+
export declare function addManifestHost(root: string, repo: string, host: string,
|
|
287
|
+
/**
|
|
288
|
+
* ADR 0153 (Q2): the path the repo answers under on the host, from an answer's path rule, set
|
|
289
|
+
* as its `basePath`. Refused when the repo gives another one.
|
|
290
|
+
*/
|
|
291
|
+
o?: {
|
|
292
|
+
basePath?: string;
|
|
293
|
+
}): Promise<{
|
|
22
294
|
manifest: string;
|
|
23
295
|
added: boolean;
|
|
24
296
|
}>;
|