flightdeck 0.3.50 → 0.4.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.
Files changed (4) hide show
  1. package/dist/lib.d.ts +141 -701
  2. package/dist/lib.d.ts.map +1 -1
  3. package/gen/lnav-format-schema.gen.ts +40 -27
  4. package/package.json +3 -3
package/dist/lib.d.ts CHANGED
@@ -3,785 +3,225 @@ import { Future } from "atom.io/internal";
3
3
  import { ChildSocket } from "atom.io/realtime-server";
4
4
  import { CronJob } from "cron";
5
5
  import { FilesystemStorage } from "safedeposit";
6
- import { z } from "zod/v3";
6
+ import { z } from "zod";
7
7
 
8
8
  //#region gen/lnav-format-schema.gen.d.ts
9
9
  declare const lnavFormatSchema: z.ZodObject<{
10
- regex: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
10
+ regex: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
11
11
  pattern: z.ZodOptional<z.ZodString>;
12
12
  "module-format": z.ZodOptional<z.ZodBoolean>;
13
- }, "strict", z.ZodTypeAny, {
14
- pattern?: string | undefined;
15
- "module-format"?: boolean | undefined;
16
- }, {
17
- pattern?: string | undefined;
18
- "module-format"?: boolean | undefined;
19
- }>, z.ZodNever]>>, Record<string, {
20
- pattern?: string | undefined;
21
- "module-format"?: boolean | undefined;
22
- }>, Record<string, {
23
- pattern?: string | undefined;
24
- "module-format"?: boolean | undefined;
25
- }>>>;
13
+ }, z.core.$strict>, z.ZodNever]>>>;
26
14
  json: z.ZodOptional<z.ZodBoolean>;
27
15
  "convert-to-local-time": z.ZodOptional<z.ZodBoolean>;
28
16
  "hide-extra": z.ZodOptional<z.ZodBoolean>;
29
17
  multiline: z.ZodOptional<z.ZodBoolean>;
30
- "timestamp-divisor": z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
18
+ "timestamp-divisor": z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodNumber]>>;
31
19
  "file-pattern": z.ZodOptional<z.ZodString>;
32
20
  converter: z.ZodOptional<z.ZodObject<{
33
21
  type: z.ZodOptional<z.ZodString>;
34
22
  header: z.ZodOptional<z.ZodObject<{
35
- expr: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNever]>>, Record<string, string>, Record<string, string>>>;
23
+ expr: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNever]>>>;
36
24
  size: z.ZodOptional<z.ZodNumber>;
37
- }, "strict", z.ZodTypeAny, {
38
- expr?: Record<string, string> | undefined;
39
- size?: number | undefined;
40
- }, {
41
- expr?: Record<string, string> | undefined;
42
- size?: number | undefined;
43
- }>>;
25
+ }, z.core.$strict>>;
44
26
  command: z.ZodOptional<z.ZodString>;
45
- }, "strict", z.ZodTypeAny, {
46
- type?: string | undefined;
47
- header?: {
48
- expr?: Record<string, string> | undefined;
49
- size?: number | undefined;
50
- } | undefined;
51
- command?: string | undefined;
52
- }, {
53
- type?: string | undefined;
54
- header?: {
55
- expr?: Record<string, string> | undefined;
56
- size?: number | undefined;
57
- } | undefined;
58
- command?: string | undefined;
59
- }>>;
27
+ }, z.core.$strict>>;
60
28
  "level-field": z.ZodOptional<z.ZodString>;
61
29
  "level-pointer": z.ZodOptional<z.ZodString>;
62
30
  "timestamp-field": z.ZodOptional<z.ZodString>;
63
31
  "subsecond-field": z.ZodOptional<z.ZodString>;
64
- "subsecond-units": z.ZodOptional<z.ZodEnum<["milli", "micro", "nano"]>>;
32
+ "subsecond-units": z.ZodOptional<z.ZodEnum<{
33
+ milli: "milli";
34
+ micro: "micro";
35
+ nano: "nano";
36
+ }>>;
65
37
  "time-field": z.ZodOptional<z.ZodString>;
66
38
  "body-field": z.ZodOptional<z.ZodString>;
67
- url: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
39
+ url: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>>;
68
40
  title: z.ZodOptional<z.ZodString>;
69
41
  description: z.ZodOptional<z.ZodString>;
70
- "timestamp-format": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
42
+ "timestamp-format": z.ZodOptional<z.ZodArray<z.ZodString>>;
71
43
  "module-field": z.ZodOptional<z.ZodString>;
72
44
  "opid-field": z.ZodOptional<z.ZodString>;
73
45
  opid: z.ZodOptional<z.ZodObject<{
74
46
  subid: z.ZodOptional<z.ZodString>;
75
- description: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
47
+ description: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
76
48
  format: z.ZodOptional<z.ZodArray<z.ZodObject<{
77
49
  field: z.ZodOptional<z.ZodString>;
78
50
  extractor: z.ZodOptional<z.ZodString>;
79
51
  prefix: z.ZodOptional<z.ZodString>;
80
52
  suffix: z.ZodOptional<z.ZodString>;
81
53
  joiner: z.ZodOptional<z.ZodString>;
82
- }, "strict", z.ZodTypeAny, {
83
- field?: string | undefined;
84
- extractor?: string | undefined;
85
- prefix?: string | undefined;
86
- suffix?: string | undefined;
87
- joiner?: string | undefined;
88
- }, {
89
- field?: string | undefined;
90
- extractor?: string | undefined;
91
- prefix?: string | undefined;
92
- suffix?: string | undefined;
93
- joiner?: string | undefined;
94
- }>, "many">>;
95
- }, "strict", z.ZodTypeAny, {
96
- format?: {
97
- field?: string | undefined;
98
- extractor?: string | undefined;
99
- prefix?: string | undefined;
100
- suffix?: string | undefined;
101
- joiner?: string | undefined;
102
- }[] | undefined;
103
- }, {
104
- format?: {
105
- field?: string | undefined;
106
- extractor?: string | undefined;
107
- prefix?: string | undefined;
108
- suffix?: string | undefined;
109
- joiner?: string | undefined;
110
- }[] | undefined;
111
- }>, z.ZodNever]>>, Record<string, {
112
- format?: {
113
- field?: string | undefined;
114
- extractor?: string | undefined;
115
- prefix?: string | undefined;
116
- suffix?: string | undefined;
117
- joiner?: string | undefined;
118
- }[] | undefined;
119
- }>, Record<string, {
120
- format?: {
121
- field?: string | undefined;
122
- extractor?: string | undefined;
123
- prefix?: string | undefined;
124
- suffix?: string | undefined;
125
- joiner?: string | undefined;
126
- }[] | undefined;
127
- }>>>;
128
- "sub-description": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
54
+ }, z.core.$strict>>>;
55
+ }, z.core.$strict>, z.ZodNever]>>>;
56
+ "sub-description": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
129
57
  format: z.ZodOptional<z.ZodArray<z.ZodObject<{
130
58
  field: z.ZodOptional<z.ZodString>;
131
59
  extractor: z.ZodOptional<z.ZodString>;
132
60
  prefix: z.ZodOptional<z.ZodString>;
133
61
  suffix: z.ZodOptional<z.ZodString>;
134
62
  joiner: z.ZodOptional<z.ZodString>;
135
- }, "strict", z.ZodTypeAny, {
136
- field?: string | undefined;
137
- extractor?: string | undefined;
138
- prefix?: string | undefined;
139
- suffix?: string | undefined;
140
- joiner?: string | undefined;
141
- }, {
142
- field?: string | undefined;
143
- extractor?: string | undefined;
144
- prefix?: string | undefined;
145
- suffix?: string | undefined;
146
- joiner?: string | undefined;
147
- }>, "many">>;
148
- }, "strict", z.ZodTypeAny, {
149
- format?: {
150
- field?: string | undefined;
151
- extractor?: string | undefined;
152
- prefix?: string | undefined;
153
- suffix?: string | undefined;
154
- joiner?: string | undefined;
155
- }[] | undefined;
156
- }, {
157
- format?: {
158
- field?: string | undefined;
159
- extractor?: string | undefined;
160
- prefix?: string | undefined;
161
- suffix?: string | undefined;
162
- joiner?: string | undefined;
163
- }[] | undefined;
164
- }>, z.ZodNever]>>, Record<string, {
165
- format?: {
166
- field?: string | undefined;
167
- extractor?: string | undefined;
168
- prefix?: string | undefined;
169
- suffix?: string | undefined;
170
- joiner?: string | undefined;
171
- }[] | undefined;
172
- }>, Record<string, {
173
- format?: {
174
- field?: string | undefined;
175
- extractor?: string | undefined;
176
- prefix?: string | undefined;
177
- suffix?: string | undefined;
178
- joiner?: string | undefined;
179
- }[] | undefined;
180
- }>>>;
181
- }, "strict", z.ZodTypeAny, {
182
- description?: Record<string, {
183
- format?: {
184
- field?: string | undefined;
185
- extractor?: string | undefined;
186
- prefix?: string | undefined;
187
- suffix?: string | undefined;
188
- joiner?: string | undefined;
189
- }[] | undefined;
190
- }> | undefined;
191
- subid?: string | undefined;
192
- "sub-description"?: Record<string, {
193
- format?: {
194
- field?: string | undefined;
195
- extractor?: string | undefined;
196
- prefix?: string | undefined;
197
- suffix?: string | undefined;
198
- joiner?: string | undefined;
199
- }[] | undefined;
200
- }> | undefined;
201
- }, {
202
- description?: Record<string, {
203
- format?: {
204
- field?: string | undefined;
205
- extractor?: string | undefined;
206
- prefix?: string | undefined;
207
- suffix?: string | undefined;
208
- joiner?: string | undefined;
209
- }[] | undefined;
210
- }> | undefined;
211
- subid?: string | undefined;
212
- "sub-description"?: Record<string, {
213
- format?: {
214
- field?: string | undefined;
215
- extractor?: string | undefined;
216
- prefix?: string | undefined;
217
- suffix?: string | undefined;
218
- joiner?: string | undefined;
219
- }[] | undefined;
220
- }> | undefined;
221
- }>>;
63
+ }, z.core.$strict>>>;
64
+ }, z.core.$strict>, z.ZodNever]>>>;
65
+ }, z.core.$strict>>;
222
66
  "ordered-by-time": z.ZodOptional<z.ZodBoolean>;
223
- level: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodNever]>>, Record<string, string | number>, Record<string, string | number>>>;
224
- value: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
225
- kind: z.ZodOptional<z.ZodEnum<["string", "integer", "float", "boolean", "json", "struct", "quoted", "xml"]>>;
67
+ level: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodNever]>>>;
68
+ value: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
69
+ kind: z.ZodOptional<z.ZodEnum<{
70
+ string: "string";
71
+ boolean: "boolean";
72
+ json: "json";
73
+ integer: "integer";
74
+ float: "float";
75
+ struct: "struct";
76
+ quoted: "quoted";
77
+ xml: "xml";
78
+ }>>;
226
79
  collate: z.ZodOptional<z.ZodString>;
227
80
  unit: z.ZodOptional<z.ZodObject<{
228
81
  field: z.ZodOptional<z.ZodString>;
229
- "scaling-factor": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
230
- op: z.ZodOptional<z.ZodEnum<["identity", "multiply", "divide"]>>;
82
+ "scaling-factor": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
83
+ op: z.ZodOptional<z.ZodEnum<{
84
+ identity: "identity";
85
+ multiply: "multiply";
86
+ divide: "divide";
87
+ }>>;
231
88
  value: z.ZodOptional<z.ZodNumber>;
232
- }, "strict", z.ZodTypeAny, {
233
- value?: number | undefined;
234
- op?: "identity" | "multiply" | "divide" | undefined;
235
- }, {
236
- value?: number | undefined;
237
- op?: "identity" | "multiply" | "divide" | undefined;
238
- }>, z.ZodNever]>>, Record<string, {
239
- value?: number | undefined;
240
- op?: "identity" | "multiply" | "divide" | undefined;
241
- }>, Record<string, {
242
- value?: number | undefined;
243
- op?: "identity" | "multiply" | "divide" | undefined;
244
- }>>>;
245
- }, "strict", z.ZodTypeAny, {
246
- field?: string | undefined;
247
- "scaling-factor"?: Record<string, {
248
- value?: number | undefined;
249
- op?: "identity" | "multiply" | "divide" | undefined;
250
- }> | undefined;
251
- }, {
252
- field?: string | undefined;
253
- "scaling-factor"?: Record<string, {
254
- value?: number | undefined;
255
- op?: "identity" | "multiply" | "divide" | undefined;
256
- }> | undefined;
257
- }>>;
89
+ }, z.core.$strict>, z.ZodNever]>>>;
90
+ }, z.core.$strict>>;
258
91
  identifier: z.ZodOptional<z.ZodBoolean>;
259
92
  "foreign-key": z.ZodOptional<z.ZodBoolean>;
260
93
  hidden: z.ZodOptional<z.ZodBoolean>;
261
- "action-list": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
94
+ "action-list": z.ZodOptional<z.ZodArray<z.ZodString>>;
262
95
  rewriter: z.ZodOptional<z.ZodString>;
263
96
  description: z.ZodOptional<z.ZodString>;
264
- }, "strict", z.ZodTypeAny, {
265
- description?: string | undefined;
266
- kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
267
- collate?: string | undefined;
268
- unit?: {
269
- field?: string | undefined;
270
- "scaling-factor"?: Record<string, {
271
- value?: number | undefined;
272
- op?: "identity" | "multiply" | "divide" | undefined;
273
- }> | undefined;
274
- } | undefined;
275
- identifier?: boolean | undefined;
276
- "foreign-key"?: boolean | undefined;
277
- hidden?: boolean | undefined;
278
- "action-list"?: string[] | undefined;
279
- rewriter?: string | undefined;
280
- }, {
281
- description?: string | undefined;
282
- kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
283
- collate?: string | undefined;
284
- unit?: {
285
- field?: string | undefined;
286
- "scaling-factor"?: Record<string, {
287
- value?: number | undefined;
288
- op?: "identity" | "multiply" | "divide" | undefined;
289
- }> | undefined;
290
- } | undefined;
291
- identifier?: boolean | undefined;
292
- "foreign-key"?: boolean | undefined;
293
- hidden?: boolean | undefined;
294
- "action-list"?: string[] | undefined;
295
- rewriter?: string | undefined;
296
- }>, z.ZodNever]>>, Record<string, {
297
- description?: string | undefined;
298
- kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
299
- collate?: string | undefined;
300
- unit?: {
301
- field?: string | undefined;
302
- "scaling-factor"?: Record<string, {
303
- value?: number | undefined;
304
- op?: "identity" | "multiply" | "divide" | undefined;
305
- }> | undefined;
306
- } | undefined;
307
- identifier?: boolean | undefined;
308
- "foreign-key"?: boolean | undefined;
309
- hidden?: boolean | undefined;
310
- "action-list"?: string[] | undefined;
311
- rewriter?: string | undefined;
312
- }>, Record<string, {
313
- description?: string | undefined;
314
- kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
315
- collate?: string | undefined;
316
- unit?: {
317
- field?: string | undefined;
318
- "scaling-factor"?: Record<string, {
319
- value?: number | undefined;
320
- op?: "identity" | "multiply" | "divide" | undefined;
321
- }> | undefined;
322
- } | undefined;
323
- identifier?: boolean | undefined;
324
- "foreign-key"?: boolean | undefined;
325
- hidden?: boolean | undefined;
326
- "action-list"?: string[] | undefined;
327
- rewriter?: string | undefined;
328
- }>>>;
329
- tags: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
97
+ }, z.core.$strict>, z.ZodNever]>>>;
98
+ tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
330
99
  paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
331
100
  glob: z.ZodOptional<z.ZodString>;
332
- }, "strict", z.ZodTypeAny, {
333
- glob?: string | undefined;
334
- }, {
335
- glob?: string | undefined;
336
- }>, "many">>;
101
+ }, z.core.$strict>>>;
337
102
  pattern: z.ZodOptional<z.ZodString>;
338
103
  description: z.ZodOptional<z.ZodString>;
339
- level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
340
- }, "strict", z.ZodTypeAny, {
341
- pattern?: string | undefined;
342
- description?: string | undefined;
343
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
344
- paths?: {
345
- glob?: string | undefined;
346
- }[] | undefined;
347
- }, {
348
- pattern?: string | undefined;
349
- description?: string | undefined;
350
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
351
- paths?: {
352
- glob?: string | undefined;
353
- }[] | undefined;
354
- }>, z.ZodNever]>>, Record<string, {
355
- pattern?: string | undefined;
356
- description?: string | undefined;
357
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
358
- paths?: {
359
- glob?: string | undefined;
360
- }[] | undefined;
361
- }>, Record<string, {
362
- pattern?: string | undefined;
363
- description?: string | undefined;
364
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
365
- paths?: {
366
- glob?: string | undefined;
367
- }[] | undefined;
368
- }>>>;
369
- partitions: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
104
+ level: z.ZodOptional<z.ZodEnum<{
105
+ info: "info";
106
+ error: "error";
107
+ trace: "trace";
108
+ debug5: "debug5";
109
+ debug4: "debug4";
110
+ debug3: "debug3";
111
+ debug2: "debug2";
112
+ debug: "debug";
113
+ stats: "stats";
114
+ notice: "notice";
115
+ warning: "warning";
116
+ critical: "critical";
117
+ fatal: "fatal";
118
+ }>>;
119
+ }, z.core.$strict>, z.ZodNever]>>>;
120
+ partitions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
370
121
  paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
371
122
  glob: z.ZodOptional<z.ZodString>;
372
- }, "strict", z.ZodTypeAny, {
373
- glob?: string | undefined;
374
- }, {
375
- glob?: string | undefined;
376
- }>, "many">>;
123
+ }, z.core.$strict>>>;
377
124
  pattern: z.ZodOptional<z.ZodString>;
378
125
  description: z.ZodOptional<z.ZodString>;
379
- level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
380
- }, "strict", z.ZodTypeAny, {
381
- pattern?: string | undefined;
382
- description?: string | undefined;
383
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
384
- paths?: {
385
- glob?: string | undefined;
386
- }[] | undefined;
387
- }, {
388
- pattern?: string | undefined;
389
- description?: string | undefined;
390
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
391
- paths?: {
392
- glob?: string | undefined;
393
- }[] | undefined;
394
- }>, z.ZodNever]>>, Record<string, {
395
- pattern?: string | undefined;
396
- description?: string | undefined;
397
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
398
- paths?: {
399
- glob?: string | undefined;
400
- }[] | undefined;
401
- }>, Record<string, {
402
- pattern?: string | undefined;
403
- description?: string | undefined;
404
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
405
- paths?: {
406
- glob?: string | undefined;
407
- }[] | undefined;
408
- }>>>;
409
- action: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodObject<{
126
+ level: z.ZodOptional<z.ZodEnum<{
127
+ info: "info";
128
+ error: "error";
129
+ trace: "trace";
130
+ debug5: "debug5";
131
+ debug4: "debug4";
132
+ debug3: "debug3";
133
+ debug2: "debug2";
134
+ debug: "debug";
135
+ stats: "stats";
136
+ notice: "notice";
137
+ warning: "warning";
138
+ critical: "critical";
139
+ fatal: "fatal";
140
+ }>>;
141
+ }, z.core.$strict>, z.ZodNever]>>>;
142
+ action: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
410
143
  label: z.ZodOptional<z.ZodString>;
411
144
  "capture-output": z.ZodOptional<z.ZodBoolean>;
412
- cmd: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
413
- }, "strict", z.ZodTypeAny, {
414
- label?: string | undefined;
415
- "capture-output"?: boolean | undefined;
416
- cmd?: string[] | undefined;
417
- }, {
418
- label?: string | undefined;
419
- "capture-output"?: boolean | undefined;
420
- cmd?: string[] | undefined;
421
- }>]>, z.ZodNever]>>, Record<string, string | {
422
- label?: string | undefined;
423
- "capture-output"?: boolean | undefined;
424
- cmd?: string[] | undefined;
425
- }>, Record<string, string | {
426
- label?: string | undefined;
427
- "capture-output"?: boolean | undefined;
428
- cmd?: string[] | undefined;
429
- }>>>;
145
+ cmd: z.ZodOptional<z.ZodArray<z.ZodString>>;
146
+ }, z.core.$strict>]>, z.ZodNever]>>>;
430
147
  sample: z.ZodOptional<z.ZodArray<z.ZodObject<{
431
148
  description: z.ZodOptional<z.ZodString>;
432
149
  line: z.ZodOptional<z.ZodString>;
433
- level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
434
- }, "strict", z.ZodTypeAny, {
435
- description?: string | undefined;
436
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
437
- line?: string | undefined;
438
- }, {
439
- description?: string | undefined;
440
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
441
- line?: string | undefined;
442
- }>, "many">>;
443
- "line-format": z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
150
+ level: z.ZodOptional<z.ZodEnum<{
151
+ info: "info";
152
+ error: "error";
153
+ trace: "trace";
154
+ debug5: "debug5";
155
+ debug4: "debug4";
156
+ debug3: "debug3";
157
+ debug2: "debug2";
158
+ debug: "debug";
159
+ stats: "stats";
160
+ notice: "notice";
161
+ warning: "warning";
162
+ critical: "critical";
163
+ fatal: "fatal";
164
+ }>>;
165
+ }, z.core.$strict>>>;
166
+ "line-format": z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
444
167
  field: z.ZodOptional<z.ZodString>;
445
168
  "default-value": z.ZodOptional<z.ZodString>;
446
169
  "timestamp-format": z.ZodOptional<z.ZodString>;
447
170
  "min-width": z.ZodOptional<z.ZodNumber>;
448
171
  "auto-width": z.ZodOptional<z.ZodBoolean>;
449
172
  "max-width": z.ZodOptional<z.ZodNumber>;
450
- align: z.ZodOptional<z.ZodEnum<["left", "right"]>>;
451
- overflow: z.ZodOptional<z.ZodEnum<["abbrev", "truncate", "dot-dot", "last-word"]>>;
452
- "text-transform": z.ZodOptional<z.ZodEnum<["none", "uppercase", "lowercase", "capitalize"]>>;
173
+ align: z.ZodOptional<z.ZodEnum<{
174
+ left: "left";
175
+ right: "right";
176
+ }>>;
177
+ overflow: z.ZodOptional<z.ZodEnum<{
178
+ abbrev: "abbrev";
179
+ truncate: "truncate";
180
+ "dot-dot": "dot-dot";
181
+ "last-word": "last-word";
182
+ }>>;
183
+ "text-transform": z.ZodOptional<z.ZodEnum<{
184
+ none: "none";
185
+ uppercase: "uppercase";
186
+ lowercase: "lowercase";
187
+ capitalize: "capitalize";
188
+ }>>;
453
189
  prefix: z.ZodOptional<z.ZodString>;
454
190
  suffix: z.ZodOptional<z.ZodString>;
455
- }, "strict", z.ZodTypeAny, {
456
- "timestamp-format"?: string | undefined;
457
- field?: string | undefined;
458
- prefix?: string | undefined;
459
- suffix?: string | undefined;
460
- "default-value"?: string | undefined;
461
- "min-width"?: number | undefined;
462
- "auto-width"?: boolean | undefined;
463
- "max-width"?: number | undefined;
464
- align?: "left" | "right" | undefined;
465
- overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
466
- "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
467
- }, {
468
- "timestamp-format"?: string | undefined;
469
- field?: string | undefined;
470
- prefix?: string | undefined;
471
- suffix?: string | undefined;
472
- "default-value"?: string | undefined;
473
- "min-width"?: number | undefined;
474
- "auto-width"?: boolean | undefined;
475
- "max-width"?: number | undefined;
476
- align?: "left" | "right" | undefined;
477
- overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
478
- "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
479
- }>]>, "many">>;
480
- "search-table": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
191
+ }, z.core.$strict>]>>>;
192
+ "search-table": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
481
193
  pattern: z.ZodOptional<z.ZodString>;
482
194
  glob: z.ZodOptional<z.ZodString>;
483
- level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
484
- }, "strict", z.ZodTypeAny, {
485
- pattern?: string | undefined;
486
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
487
- glob?: string | undefined;
488
- }, {
489
- pattern?: string | undefined;
490
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
491
- glob?: string | undefined;
492
- }>, z.ZodNever]>>, Record<string, {
493
- pattern?: string | undefined;
494
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
495
- glob?: string | undefined;
496
- }>, Record<string, {
497
- pattern?: string | undefined;
498
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
499
- glob?: string | undefined;
500
- }>>>;
501
- highlights: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
195
+ level: z.ZodOptional<z.ZodEnum<{
196
+ info: "info";
197
+ error: "error";
198
+ trace: "trace";
199
+ debug5: "debug5";
200
+ debug4: "debug4";
201
+ debug3: "debug3";
202
+ debug2: "debug2";
203
+ debug: "debug";
204
+ stats: "stats";
205
+ notice: "notice";
206
+ warning: "warning";
207
+ critical: "critical";
208
+ fatal: "fatal";
209
+ }>>;
210
+ }, z.core.$strict>, z.ZodNever]>>>;
211
+ highlights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
502
212
  pattern: z.ZodOptional<z.ZodString>;
503
213
  color: z.ZodOptional<z.ZodString>;
504
214
  "background-color": z.ZodOptional<z.ZodString>;
505
215
  underline: z.ZodOptional<z.ZodBoolean>;
506
216
  blink: z.ZodOptional<z.ZodBoolean>;
507
- }, "strict", z.ZodTypeAny, {
508
- pattern?: string | undefined;
509
- color?: string | undefined;
510
- "background-color"?: string | undefined;
511
- underline?: boolean | undefined;
512
- blink?: boolean | undefined;
513
- }, {
514
- pattern?: string | undefined;
515
- color?: string | undefined;
516
- "background-color"?: string | undefined;
517
- underline?: boolean | undefined;
518
- blink?: boolean | undefined;
519
- }>, z.ZodNever]>>, Record<string, {
520
- pattern?: string | undefined;
521
- color?: string | undefined;
522
- "background-color"?: string | undefined;
523
- underline?: boolean | undefined;
524
- blink?: boolean | undefined;
525
- }>, Record<string, {
526
- pattern?: string | undefined;
527
- color?: string | undefined;
528
- "background-color"?: string | undefined;
529
- underline?: boolean | undefined;
530
- blink?: boolean | undefined;
531
- }>>>;
532
- "file-type": z.ZodOptional<z.ZodEnum<["text", "json", "csv"]>>;
217
+ }, z.core.$strict>, z.ZodNever]>>>;
218
+ "file-type": z.ZodOptional<z.ZodEnum<{
219
+ json: "json";
220
+ text: "text";
221
+ csv: "csv";
222
+ }>>;
533
223
  "max-unrecognized-lines": z.ZodOptional<z.ZodNumber>;
534
- }, "strict", z.ZodTypeAny, {
535
- value?: Record<string, {
536
- description?: string | undefined;
537
- kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
538
- collate?: string | undefined;
539
- unit?: {
540
- field?: string | undefined;
541
- "scaling-factor"?: Record<string, {
542
- value?: number | undefined;
543
- op?: "identity" | "multiply" | "divide" | undefined;
544
- }> | undefined;
545
- } | undefined;
546
- identifier?: boolean | undefined;
547
- "foreign-key"?: boolean | undefined;
548
- hidden?: boolean | undefined;
549
- "action-list"?: string[] | undefined;
550
- rewriter?: string | undefined;
551
- }> | undefined;
552
- regex?: Record<string, {
553
- pattern?: string | undefined;
554
- "module-format"?: boolean | undefined;
555
- }> | undefined;
556
- json?: boolean | undefined;
557
- "convert-to-local-time"?: boolean | undefined;
558
- "hide-extra"?: boolean | undefined;
559
- multiline?: boolean | undefined;
560
- "timestamp-divisor"?: number | undefined;
561
- "file-pattern"?: string | undefined;
562
- converter?: {
563
- type?: string | undefined;
564
- header?: {
565
- expr?: Record<string, string> | undefined;
566
- size?: number | undefined;
567
- } | undefined;
568
- command?: string | undefined;
569
- } | undefined;
570
- "level-field"?: string | undefined;
571
- "level-pointer"?: string | undefined;
572
- "timestamp-field"?: string | undefined;
573
- "subsecond-field"?: string | undefined;
574
- "subsecond-units"?: "milli" | "micro" | "nano" | undefined;
575
- "time-field"?: string | undefined;
576
- "body-field"?: string | undefined;
577
- url?: string | string[] | undefined;
578
- title?: string | undefined;
579
- description?: string | undefined;
580
- "timestamp-format"?: string[] | undefined;
581
- "module-field"?: string | undefined;
582
- "opid-field"?: string | undefined;
583
- opid?: {
584
- description?: Record<string, {
585
- format?: {
586
- field?: string | undefined;
587
- extractor?: string | undefined;
588
- prefix?: string | undefined;
589
- suffix?: string | undefined;
590
- joiner?: string | undefined;
591
- }[] | undefined;
592
- }> | undefined;
593
- subid?: string | undefined;
594
- "sub-description"?: Record<string, {
595
- format?: {
596
- field?: string | undefined;
597
- extractor?: string | undefined;
598
- prefix?: string | undefined;
599
- suffix?: string | undefined;
600
- joiner?: string | undefined;
601
- }[] | undefined;
602
- }> | undefined;
603
- } | undefined;
604
- "ordered-by-time"?: boolean | undefined;
605
- level?: Record<string, string | number> | undefined;
606
- tags?: Record<string, {
607
- pattern?: string | undefined;
608
- description?: string | undefined;
609
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
610
- paths?: {
611
- glob?: string | undefined;
612
- }[] | undefined;
613
- }> | undefined;
614
- partitions?: Record<string, {
615
- pattern?: string | undefined;
616
- description?: string | undefined;
617
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
618
- paths?: {
619
- glob?: string | undefined;
620
- }[] | undefined;
621
- }> | undefined;
622
- action?: Record<string, string | {
623
- label?: string | undefined;
624
- "capture-output"?: boolean | undefined;
625
- cmd?: string[] | undefined;
626
- }> | undefined;
627
- sample?: {
628
- description?: string | undefined;
629
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
630
- line?: string | undefined;
631
- }[] | undefined;
632
- "line-format"?: (string | {
633
- "timestamp-format"?: string | undefined;
634
- field?: string | undefined;
635
- prefix?: string | undefined;
636
- suffix?: string | undefined;
637
- "default-value"?: string | undefined;
638
- "min-width"?: number | undefined;
639
- "auto-width"?: boolean | undefined;
640
- "max-width"?: number | undefined;
641
- align?: "left" | "right" | undefined;
642
- overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
643
- "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
644
- })[] | undefined;
645
- "search-table"?: Record<string, {
646
- pattern?: string | undefined;
647
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
648
- glob?: string | undefined;
649
- }> | undefined;
650
- highlights?: Record<string, {
651
- pattern?: string | undefined;
652
- color?: string | undefined;
653
- "background-color"?: string | undefined;
654
- underline?: boolean | undefined;
655
- blink?: boolean | undefined;
656
- }> | undefined;
657
- "file-type"?: "json" | "text" | "csv" | undefined;
658
- "max-unrecognized-lines"?: number | undefined;
659
- }, {
660
- value?: Record<string, {
661
- description?: string | undefined;
662
- kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
663
- collate?: string | undefined;
664
- unit?: {
665
- field?: string | undefined;
666
- "scaling-factor"?: Record<string, {
667
- value?: number | undefined;
668
- op?: "identity" | "multiply" | "divide" | undefined;
669
- }> | undefined;
670
- } | undefined;
671
- identifier?: boolean | undefined;
672
- "foreign-key"?: boolean | undefined;
673
- hidden?: boolean | undefined;
674
- "action-list"?: string[] | undefined;
675
- rewriter?: string | undefined;
676
- }> | undefined;
677
- regex?: Record<string, {
678
- pattern?: string | undefined;
679
- "module-format"?: boolean | undefined;
680
- }> | undefined;
681
- json?: boolean | undefined;
682
- "convert-to-local-time"?: boolean | undefined;
683
- "hide-extra"?: boolean | undefined;
684
- multiline?: boolean | undefined;
685
- "timestamp-divisor"?: number | undefined;
686
- "file-pattern"?: string | undefined;
687
- converter?: {
688
- type?: string | undefined;
689
- header?: {
690
- expr?: Record<string, string> | undefined;
691
- size?: number | undefined;
692
- } | undefined;
693
- command?: string | undefined;
694
- } | undefined;
695
- "level-field"?: string | undefined;
696
- "level-pointer"?: string | undefined;
697
- "timestamp-field"?: string | undefined;
698
- "subsecond-field"?: string | undefined;
699
- "subsecond-units"?: "milli" | "micro" | "nano" | undefined;
700
- "time-field"?: string | undefined;
701
- "body-field"?: string | undefined;
702
- url?: string | string[] | undefined;
703
- title?: string | undefined;
704
- description?: string | undefined;
705
- "timestamp-format"?: string[] | undefined;
706
- "module-field"?: string | undefined;
707
- "opid-field"?: string | undefined;
708
- opid?: {
709
- description?: Record<string, {
710
- format?: {
711
- field?: string | undefined;
712
- extractor?: string | undefined;
713
- prefix?: string | undefined;
714
- suffix?: string | undefined;
715
- joiner?: string | undefined;
716
- }[] | undefined;
717
- }> | undefined;
718
- subid?: string | undefined;
719
- "sub-description"?: Record<string, {
720
- format?: {
721
- field?: string | undefined;
722
- extractor?: string | undefined;
723
- prefix?: string | undefined;
724
- suffix?: string | undefined;
725
- joiner?: string | undefined;
726
- }[] | undefined;
727
- }> | undefined;
728
- } | undefined;
729
- "ordered-by-time"?: boolean | undefined;
730
- level?: Record<string, string | number> | undefined;
731
- tags?: Record<string, {
732
- pattern?: string | undefined;
733
- description?: string | undefined;
734
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
735
- paths?: {
736
- glob?: string | undefined;
737
- }[] | undefined;
738
- }> | undefined;
739
- partitions?: Record<string, {
740
- pattern?: string | undefined;
741
- description?: string | undefined;
742
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
743
- paths?: {
744
- glob?: string | undefined;
745
- }[] | undefined;
746
- }> | undefined;
747
- action?: Record<string, string | {
748
- label?: string | undefined;
749
- "capture-output"?: boolean | undefined;
750
- cmd?: string[] | undefined;
751
- }> | undefined;
752
- sample?: {
753
- description?: string | undefined;
754
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
755
- line?: string | undefined;
756
- }[] | undefined;
757
- "line-format"?: (string | {
758
- "timestamp-format"?: string | undefined;
759
- field?: string | undefined;
760
- prefix?: string | undefined;
761
- suffix?: string | undefined;
762
- "default-value"?: string | undefined;
763
- "min-width"?: number | undefined;
764
- "auto-width"?: boolean | undefined;
765
- "max-width"?: number | undefined;
766
- align?: "left" | "right" | undefined;
767
- overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
768
- "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
769
- })[] | undefined;
770
- "search-table"?: Record<string, {
771
- pattern?: string | undefined;
772
- level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
773
- glob?: string | undefined;
774
- }> | undefined;
775
- highlights?: Record<string, {
776
- pattern?: string | undefined;
777
- color?: string | undefined;
778
- "background-color"?: string | undefined;
779
- underline?: boolean | undefined;
780
- blink?: boolean | undefined;
781
- }> | undefined;
782
- "file-type"?: "json" | "text" | "csv" | undefined;
783
- "max-unrecognized-lines"?: number | undefined;
784
- }>;
224
+ }, z.core.$strict>;
785
225
  type LnavFormat = z.infer<typeof lnavFormatSchema>;
786
226
  //#endregion
787
227
  //#region src/flightdeck.lib.d.ts
package/dist/lib.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"lib.d.ts","names":[],"sources":["../gen/lnav-format-schema.gen.ts","../src/flightdeck.lib.ts","../src/klaxon.lib.ts"],"mappings":"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"}
1
+ {"version":3,"file":"lib.d.ts","names":[],"sources":["../gen/lnav-format-schema.gen.ts","../src/flightdeck.lib.ts","../src/klaxon.lib.ts"],"mappings":"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"}
package/gen/lnav-format-schema.gen.ts CHANGED
@@ -1,9 +1,10 @@
1
- import { z } from "zod/v3";
1
+ import { z } from "zod";
2
2
 
3
3
  export const lnavFormatSchema = z
4
4
  .object({
5
5
  regex: z
6
6
  .record(
7
+ z.string(),
7
8
  z.union([
8
9
  z
9
10
  .object({
@@ -52,7 +53,7 @@ export const lnavFormatSchema = z
52
53
  .safeParse(value[key]);
53
54
  if (!result.success) {
54
55
  ctx.addIssue({
55
- path: [...ctx.path, key],
56
+ path: [key],
56
57
  code: "custom",
57
58
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
58
59
  params: {
@@ -65,7 +66,7 @@ export const lnavFormatSchema = z
65
66
  const result = z.never().safeParse(value[key]);
66
67
  if (!result.success) {
67
68
  ctx.addIssue({
68
- path: [...ctx.path, key],
69
+ path: [key],
69
70
  code: "custom",
70
71
  message: `Invalid input: must match catchall schema`,
71
72
  params: {
@@ -129,6 +130,7 @@ export const lnavFormatSchema = z
129
130
  .object({
130
131
  expr: z
131
132
  .record(
133
+ z.string(),
132
134
  z.union([z.string().describe("SQLite expression"), z.never()]),
133
135
  )
134
136
  .superRefine((value, ctx) => {
@@ -142,7 +144,7 @@ export const lnavFormatSchema = z
142
144
  .safeParse(value[key]);
143
145
  if (!result.success) {
144
146
  ctx.addIssue({
145
- path: [...ctx.path, key],
147
+ path: [key],
146
148
  code: "custom",
147
149
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
148
150
  params: {
@@ -155,7 +157,7 @@ export const lnavFormatSchema = z
155
157
  const result = z.never().safeParse(value[key]);
156
158
  if (!result.success) {
157
159
  ctx.addIssue({
158
- path: [...ctx.path, key],
160
+ path: [key],
159
161
  code: "custom",
160
162
  message: `Invalid input: must match catchall schema`,
161
163
  params: {
@@ -263,6 +265,7 @@ export const lnavFormatSchema = z
263
265
  .optional(),
264
266
  description: z
265
267
  .record(
268
+ z.string(),
266
269
  z.union([
267
270
  z
268
271
  .object({
@@ -367,7 +370,7 @@ export const lnavFormatSchema = z
367
370
  .safeParse(value[key]);
368
371
  if (!result.success) {
369
372
  ctx.addIssue({
370
- path: [...ctx.path, key],
373
+ path: [key],
371
374
  code: "custom",
372
375
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
373
376
  params: {
@@ -380,7 +383,7 @@ export const lnavFormatSchema = z
380
383
  const result = z.never().safeParse(value[key]);
381
384
  if (!result.success) {
382
385
  ctx.addIssue({
383
- path: [...ctx.path, key],
386
+ path: [key],
384
387
  code: "custom",
385
388
  message: `Invalid input: must match catchall schema`,
386
389
  params: {
@@ -395,6 +398,7 @@ export const lnavFormatSchema = z
395
398
  .optional(),
396
399
  "sub-description": z
397
400
  .record(
401
+ z.string(),
398
402
  z.union([
399
403
  z
400
404
  .object({
@@ -499,7 +503,7 @@ export const lnavFormatSchema = z
499
503
  .safeParse(value[key]);
500
504
  if (!result.success) {
501
505
  ctx.addIssue({
502
- path: [...ctx.path, key],
506
+ path: [key],
503
507
  code: "custom",
504
508
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
505
509
  params: {
@@ -512,7 +516,7 @@ export const lnavFormatSchema = z
512
516
  const result = z.never().safeParse(value[key]);
513
517
  if (!result.success) {
514
518
  ctx.addIssue({
515
- path: [...ctx.path, key],
519
+ path: [key],
516
520
  code: "custom",
517
521
  message: `Invalid input: must match catchall schema`,
518
522
  params: {
@@ -537,6 +541,7 @@ export const lnavFormatSchema = z
537
541
  .optional(),
538
542
  level: z
539
543
  .record(
544
+ z.string(),
540
545
  z.union([
541
546
  z
542
547
  .union([
@@ -587,7 +592,7 @@ export const lnavFormatSchema = z
587
592
  .safeParse(value[key]);
588
593
  if (!result.success) {
589
594
  ctx.addIssue({
590
- path: [...ctx.path, key],
595
+ path: [key],
591
596
  code: "custom",
592
597
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
593
598
  params: {
@@ -600,7 +605,7 @@ export const lnavFormatSchema = z
600
605
  const result = z.never().safeParse(value[key]);
601
606
  if (!result.success) {
602
607
  ctx.addIssue({
603
- path: [...ctx.path, key],
608
+ path: [key],
604
609
  code: "custom",
605
610
  message: `Invalid input: must match catchall schema`,
606
611
  params: {
@@ -615,6 +620,7 @@ export const lnavFormatSchema = z
615
620
  .optional(),
616
621
  value: z
617
622
  .record(
623
+ z.string(),
618
624
  z.union([
619
625
  z
620
626
  .object({
@@ -645,6 +651,7 @@ export const lnavFormatSchema = z
645
651
  .optional(),
646
652
  "scaling-factor": z
647
653
  .record(
654
+ z.string(),
648
655
  z.union([
649
656
  z
650
657
  .object({
@@ -673,7 +680,7 @@ export const lnavFormatSchema = z
673
680
  .safeParse(value[key]);
674
681
  if (!result.success) {
675
682
  ctx.addIssue({
676
- path: [...ctx.path, key],
683
+ path: [key],
677
684
  code: "custom",
678
685
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
679
686
  params: {
@@ -686,7 +693,7 @@ export const lnavFormatSchema = z
686
693
  const result = z.never().safeParse(value[key]);
687
694
  if (!result.success) {
688
695
  ctx.addIssue({
689
- path: [...ctx.path, key],
696
+ path: [key],
690
697
  code: "custom",
691
698
  message: `Invalid input: must match catchall schema`,
692
699
  params: {
@@ -777,6 +784,7 @@ export const lnavFormatSchema = z
777
784
  .optional(),
778
785
  "scaling-factor": z
779
786
  .record(
787
+ z.string(),
780
788
  z.union([
781
789
  z
782
790
  .object({
@@ -805,7 +813,7 @@ export const lnavFormatSchema = z
805
813
  .safeParse(value[key]);
806
814
  if (!result.success) {
807
815
  ctx.addIssue({
808
- path: [...ctx.path, key],
816
+ path: [key],
809
817
  code: "custom",
810
818
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
811
819
  params: {
@@ -818,7 +826,7 @@ export const lnavFormatSchema = z
818
826
  const result = z.never().safeParse(value[key]);
819
827
  if (!result.success) {
820
828
  ctx.addIssue({
821
- path: [...ctx.path, key],
829
+ path: [key],
822
830
  code: "custom",
823
831
  message: `Invalid input: must match catchall schema`,
824
832
  params: {
@@ -877,7 +885,7 @@ export const lnavFormatSchema = z
877
885
  .safeParse(value[key]);
878
886
  if (!result.success) {
879
887
  ctx.addIssue({
880
- path: [...ctx.path, key],
888
+ path: [key],
881
889
  code: "custom",
882
890
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
883
891
  params: {
@@ -890,7 +898,7 @@ export const lnavFormatSchema = z
890
898
  const result = z.never().safeParse(value[key]);
891
899
  if (!result.success) {
892
900
  ctx.addIssue({
893
- path: [...ctx.path, key],
901
+ path: [key],
894
902
  code: "custom",
895
903
  message: `Invalid input: must match catchall schema`,
896
904
  params: {
@@ -905,6 +913,7 @@ export const lnavFormatSchema = z
905
913
  .optional(),
906
914
  tags: z
907
915
  .record(
916
+ z.string(),
908
917
  z.union([
909
918
  z
910
919
  .object({
@@ -1009,7 +1018,7 @@ export const lnavFormatSchema = z
1009
1018
  .safeParse(value[key]);
1010
1019
  if (!result.success) {
1011
1020
  ctx.addIssue({
1012
- path: [...ctx.path, key],
1021
+ path: [key],
1013
1022
  code: "custom",
1014
1023
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
1015
1024
  params: {
@@ -1022,7 +1031,7 @@ export const lnavFormatSchema = z
1022
1031
  const result = z.never().safeParse(value[key]);
1023
1032
  if (!result.success) {
1024
1033
  ctx.addIssue({
1025
- path: [...ctx.path, key],
1034
+ path: [key],
1026
1035
  code: "custom",
1027
1036
  message: `Invalid input: must match catchall schema`,
1028
1037
  params: {
@@ -1037,6 +1046,7 @@ export const lnavFormatSchema = z
1037
1046
  .optional(),
1038
1047
  partitions: z
1039
1048
  .record(
1049
+ z.string(),
1040
1050
  z.union([
1041
1051
  z
1042
1052
  .object({
@@ -1141,7 +1151,7 @@ export const lnavFormatSchema = z
1141
1151
  .safeParse(value[key]);
1142
1152
  if (!result.success) {
1143
1153
  ctx.addIssue({
1144
- path: [...ctx.path, key],
1154
+ path: [key],
1145
1155
  code: "custom",
1146
1156
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
1147
1157
  params: {
@@ -1154,7 +1164,7 @@ export const lnavFormatSchema = z
1154
1164
  const result = z.never().safeParse(value[key]);
1155
1165
  if (!result.success) {
1156
1166
  ctx.addIssue({
1157
- path: [...ctx.path, key],
1167
+ path: [key],
1158
1168
  code: "custom",
1159
1169
  message: `Invalid input: must match catchall schema`,
1160
1170
  params: {
@@ -1169,6 +1179,7 @@ export const lnavFormatSchema = z
1169
1179
  .optional(),
1170
1180
  action: z
1171
1181
  .record(
1182
+ z.string(),
1172
1183
  z.union([
1173
1184
  z.union([
1174
1185
  z.string(),
@@ -1202,7 +1213,7 @@ export const lnavFormatSchema = z
1202
1213
  .safeParse(value[key]);
1203
1214
  if (!result.success) {
1204
1215
  ctx.addIssue({
1205
- path: [...ctx.path, key],
1216
+ path: [key],
1206
1217
  code: "custom",
1207
1218
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
1208
1219
  params: {
@@ -1215,7 +1226,7 @@ export const lnavFormatSchema = z
1215
1226
  const result = z.never().safeParse(value[key]);
1216
1227
  if (!result.success) {
1217
1228
  ctx.addIssue({
1218
- path: [...ctx.path, key],
1229
+ path: [key],
1219
1230
  code: "custom",
1220
1231
  message: `Invalid input: must match catchall schema`,
1221
1232
  params: {
@@ -1337,6 +1348,7 @@ export const lnavFormatSchema = z
1337
1348
  .optional(),
1338
1349
  "search-table": z
1339
1350
  .record(
1351
+ z.string(),
1340
1352
  z.union([
1341
1353
  z
1342
1354
  .object({
@@ -1415,7 +1427,7 @@ export const lnavFormatSchema = z
1415
1427
  .safeParse(value[key]);
1416
1428
  if (!result.success) {
1417
1429
  ctx.addIssue({
1418
- path: [...ctx.path, key],
1430
+ path: [key],
1419
1431
  code: "custom",
1420
1432
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
1421
1433
  params: {
@@ -1428,7 +1440,7 @@ export const lnavFormatSchema = z
1428
1440
  const result = z.never().safeParse(value[key]);
1429
1441
  if (!result.success) {
1430
1442
  ctx.addIssue({
1431
- path: [...ctx.path, key],
1443
+ path: [key],
1432
1444
  code: "custom",
1433
1445
  message: `Invalid input: must match catchall schema`,
1434
1446
  params: {
@@ -1443,6 +1455,7 @@ export const lnavFormatSchema = z
1443
1455
  .optional(),
1444
1456
  highlights: z
1445
1457
  .record(
1458
+ z.string(),
1446
1459
  z.union([
1447
1460
  z
1448
1461
  .object({
@@ -1513,7 +1526,7 @@ export const lnavFormatSchema = z
1513
1526
  .safeParse(value[key]);
1514
1527
  if (!result.success) {
1515
1528
  ctx.addIssue({
1516
- path: [...ctx.path, key],
1529
+ path: [key],
1517
1530
  code: "custom",
1518
1531
  message: `Invalid input: Key matching regex /${key}/ must match schema`,
1519
1532
  params: {
@@ -1526,7 +1539,7 @@ export const lnavFormatSchema = z
1526
1539
  const result = z.never().safeParse(value[key]);
1527
1540
  if (!result.success) {
1528
1541
  ctx.addIssue({
1529
- path: [...ctx.path, key],
1542
+ path: [key],
1530
1543
  code: "custom",
1531
1544
  message: `Invalid input: must match catchall schema`,
1532
1545
  params: {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "flightdeck",
3
- "version": "0.3.50",
3
+ "version": "0.4.1",
4
4
  "license": "MIT",
5
5
  "author": {
6
6
  "name": "Jeremy Banka",
@@ -33,7 +33,7 @@
33
33
  "@t3-oss/env-core": "0.13.11",
34
34
  "arktype": "2.2.0",
35
35
  "cron": "4.4.0",
36
- "atom.io": "0.46.28",
36
+ "atom.io": "0.46.29",
37
37
  "comline": "0.4.4",
38
38
  "safedeposit": "0.1.2"
39
39
  },
@@ -46,7 +46,7 @@
46
46
  "@typescript/native-preview": "7.0.0-dev.20260327.2",
47
47
  "concurrently": "9.2.1",
48
48
  "eslint": "10.1.0",
49
- "json-schema-to-zod": "2.7.0",
49
+ "json-schema-to-zod": "2.8.0",
50
50
  "rimraf": "6.1.3",
51
51
  "tmp": "0.2.5",
52
52
  "tsdown": "0.21.6",