@michaelfromyeg/loom-schema 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/dist/index.d.ts +1043 -0
- package/dist/index.js +384 -0
- package/dist/index.js.map +1 -0
- package/package.json +55 -0
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,1043 @@
|
|
|
1
|
+
import * as zod_v4_core from 'zod/v4/core';
|
|
2
|
+
import * as zod from 'zod';
|
|
3
|
+
import { z } from 'zod';
|
|
4
|
+
|
|
5
|
+
/** The five coding-agent harnesses Loom compiles to. */
|
|
6
|
+
declare const Target: z.ZodEnum<{
|
|
7
|
+
claude: "claude";
|
|
8
|
+
codex: "codex";
|
|
9
|
+
cursor: "cursor";
|
|
10
|
+
copilot: "copilot";
|
|
11
|
+
opencode: "opencode";
|
|
12
|
+
}>;
|
|
13
|
+
type Target = z.infer<typeof Target>;
|
|
14
|
+
declare const ALL_TARGETS: readonly Target[];
|
|
15
|
+
/** Reverse-DNS namespace, e.g. `com.acme`. */
|
|
16
|
+
declare const Namespace: z.ZodString;
|
|
17
|
+
declare const Owner: z.ZodObject<{
|
|
18
|
+
name: z.ZodString;
|
|
19
|
+
namespace: z.ZodString;
|
|
20
|
+
email: z.ZodOptional<z.ZodEmail>;
|
|
21
|
+
}, z.core.$strip>;
|
|
22
|
+
type Owner = z.infer<typeof Owner>;
|
|
23
|
+
/** A config value a component reads at runtime. Declared, never stored (§11). */
|
|
24
|
+
declare const ConfigVar: z.ZodObject<{
|
|
25
|
+
env: z.ZodString;
|
|
26
|
+
secret: z.ZodDefault<z.ZodBoolean>;
|
|
27
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
28
|
+
default: z.ZodOptional<z.ZodString>;
|
|
29
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
30
|
+
}, z.core.$strip>;
|
|
31
|
+
type ConfigVar = z.infer<typeof ConfigVar>;
|
|
32
|
+
/** The seven primitive component kinds. `passthrough` is verbatim/single-target. */
|
|
33
|
+
declare const COMPONENT_KINDS: readonly ["skill", "mcp", "agent", "hook", "command", "passthrough"];
|
|
34
|
+
type ComponentKind = (typeof COMPONENT_KINDS)[number];
|
|
35
|
+
declare const SkillComponent: z.ZodObject<{
|
|
36
|
+
skill: z.ZodString;
|
|
37
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
38
|
+
claude: "claude";
|
|
39
|
+
codex: "codex";
|
|
40
|
+
cursor: "cursor";
|
|
41
|
+
copilot: "copilot";
|
|
42
|
+
opencode: "opencode";
|
|
43
|
+
}>>>;
|
|
44
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
45
|
+
}, z.core.$strict>;
|
|
46
|
+
declare const McpComponent: z.ZodObject<{
|
|
47
|
+
mcp: z.ZodString;
|
|
48
|
+
config: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
49
|
+
env: z.ZodString;
|
|
50
|
+
secret: z.ZodDefault<z.ZodBoolean>;
|
|
51
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
52
|
+
default: z.ZodOptional<z.ZodString>;
|
|
53
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
54
|
+
}, z.core.$strip>>>;
|
|
55
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
56
|
+
claude: "claude";
|
|
57
|
+
codex: "codex";
|
|
58
|
+
cursor: "cursor";
|
|
59
|
+
copilot: "copilot";
|
|
60
|
+
opencode: "opencode";
|
|
61
|
+
}>>>;
|
|
62
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
63
|
+
}, z.core.$strict>;
|
|
64
|
+
declare const AgentComponent: z.ZodObject<{
|
|
65
|
+
agent: z.ZodString;
|
|
66
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
67
|
+
claude: "claude";
|
|
68
|
+
codex: "codex";
|
|
69
|
+
cursor: "cursor";
|
|
70
|
+
copilot: "copilot";
|
|
71
|
+
opencode: "opencode";
|
|
72
|
+
}>>>;
|
|
73
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
74
|
+
}, z.core.$strict>;
|
|
75
|
+
declare const HookComponent: z.ZodObject<{
|
|
76
|
+
hook: z.ZodString;
|
|
77
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
78
|
+
claude: "claude";
|
|
79
|
+
codex: "codex";
|
|
80
|
+
cursor: "cursor";
|
|
81
|
+
copilot: "copilot";
|
|
82
|
+
opencode: "opencode";
|
|
83
|
+
}>>>;
|
|
84
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
85
|
+
}, z.core.$strict>;
|
|
86
|
+
declare const CommandComponent: z.ZodObject<{
|
|
87
|
+
command: z.ZodString;
|
|
88
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
89
|
+
claude: "claude";
|
|
90
|
+
codex: "codex";
|
|
91
|
+
cursor: "cursor";
|
|
92
|
+
copilot: "copilot";
|
|
93
|
+
opencode: "opencode";
|
|
94
|
+
}>>>;
|
|
95
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
96
|
+
}, z.core.$strict>;
|
|
97
|
+
/** A verbatim executable artifact bound to a single harness. Placed DISABLED. */
|
|
98
|
+
declare const PassthroughComponent: z.ZodObject<{
|
|
99
|
+
passthrough: z.ZodString;
|
|
100
|
+
target: z.ZodEnum<{
|
|
101
|
+
claude: "claude";
|
|
102
|
+
codex: "codex";
|
|
103
|
+
cursor: "cursor";
|
|
104
|
+
copilot: "copilot";
|
|
105
|
+
opencode: "opencode";
|
|
106
|
+
}>;
|
|
107
|
+
kind: z.ZodEnum<{
|
|
108
|
+
hook: "hook";
|
|
109
|
+
plugin: "plugin";
|
|
110
|
+
script: "script";
|
|
111
|
+
}>;
|
|
112
|
+
default_enabled: z.ZodDefault<z.ZodBoolean>;
|
|
113
|
+
}, z.core.$strict>;
|
|
114
|
+
declare const Component: z.ZodUnion<readonly [z.ZodObject<{
|
|
115
|
+
skill: z.ZodString;
|
|
116
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
117
|
+
claude: "claude";
|
|
118
|
+
codex: "codex";
|
|
119
|
+
cursor: "cursor";
|
|
120
|
+
copilot: "copilot";
|
|
121
|
+
opencode: "opencode";
|
|
122
|
+
}>>>;
|
|
123
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
124
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
125
|
+
mcp: z.ZodString;
|
|
126
|
+
config: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
127
|
+
env: z.ZodString;
|
|
128
|
+
secret: z.ZodDefault<z.ZodBoolean>;
|
|
129
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
130
|
+
default: z.ZodOptional<z.ZodString>;
|
|
131
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
132
|
+
}, z.core.$strip>>>;
|
|
133
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
134
|
+
claude: "claude";
|
|
135
|
+
codex: "codex";
|
|
136
|
+
cursor: "cursor";
|
|
137
|
+
copilot: "copilot";
|
|
138
|
+
opencode: "opencode";
|
|
139
|
+
}>>>;
|
|
140
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
141
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
142
|
+
agent: z.ZodString;
|
|
143
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
144
|
+
claude: "claude";
|
|
145
|
+
codex: "codex";
|
|
146
|
+
cursor: "cursor";
|
|
147
|
+
copilot: "copilot";
|
|
148
|
+
opencode: "opencode";
|
|
149
|
+
}>>>;
|
|
150
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
151
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
152
|
+
hook: z.ZodString;
|
|
153
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
154
|
+
claude: "claude";
|
|
155
|
+
codex: "codex";
|
|
156
|
+
cursor: "cursor";
|
|
157
|
+
copilot: "copilot";
|
|
158
|
+
opencode: "opencode";
|
|
159
|
+
}>>>;
|
|
160
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
161
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
162
|
+
command: z.ZodString;
|
|
163
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
164
|
+
claude: "claude";
|
|
165
|
+
codex: "codex";
|
|
166
|
+
cursor: "cursor";
|
|
167
|
+
copilot: "copilot";
|
|
168
|
+
opencode: "opencode";
|
|
169
|
+
}>>>;
|
|
170
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
171
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
172
|
+
passthrough: z.ZodString;
|
|
173
|
+
target: z.ZodEnum<{
|
|
174
|
+
claude: "claude";
|
|
175
|
+
codex: "codex";
|
|
176
|
+
cursor: "cursor";
|
|
177
|
+
copilot: "copilot";
|
|
178
|
+
opencode: "opencode";
|
|
179
|
+
}>;
|
|
180
|
+
kind: z.ZodEnum<{
|
|
181
|
+
hook: "hook";
|
|
182
|
+
plugin: "plugin";
|
|
183
|
+
script: "script";
|
|
184
|
+
}>;
|
|
185
|
+
default_enabled: z.ZodDefault<z.ZodBoolean>;
|
|
186
|
+
}, z.core.$strict>]>;
|
|
187
|
+
type Component = z.infer<typeof Component>;
|
|
188
|
+
/** Source forms accepted for a plugin reference. */
|
|
189
|
+
declare const Dependency: z.ZodObject<{
|
|
190
|
+
plugin: z.ZodString;
|
|
191
|
+
version: z.ZodOptional<z.ZodString>;
|
|
192
|
+
components: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
193
|
+
}, z.core.$strip>;
|
|
194
|
+
type Dependency = z.infer<typeof Dependency>;
|
|
195
|
+
declare const Trust: z.ZodObject<{
|
|
196
|
+
sign: z.ZodDefault<z.ZodBoolean>;
|
|
197
|
+
scan: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
198
|
+
schema: "schema";
|
|
199
|
+
security: "security";
|
|
200
|
+
}>>>;
|
|
201
|
+
}, z.core.$strip>;
|
|
202
|
+
type Trust = z.infer<typeof Trust>;
|
|
203
|
+
/** `loom.yaml` — the single file an author writes. */
|
|
204
|
+
declare const Plugin: z.ZodObject<{
|
|
205
|
+
name: z.ZodString;
|
|
206
|
+
version: z.ZodString;
|
|
207
|
+
owner: z.ZodObject<{
|
|
208
|
+
name: z.ZodString;
|
|
209
|
+
namespace: z.ZodString;
|
|
210
|
+
email: z.ZodOptional<z.ZodEmail>;
|
|
211
|
+
}, z.core.$strip>;
|
|
212
|
+
description: z.ZodOptional<z.ZodString>;
|
|
213
|
+
license: z.ZodOptional<z.ZodString>;
|
|
214
|
+
loom_min_version: z.ZodOptional<z.ZodString>;
|
|
215
|
+
components: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
|
|
216
|
+
skill: z.ZodString;
|
|
217
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
218
|
+
claude: "claude";
|
|
219
|
+
codex: "codex";
|
|
220
|
+
cursor: "cursor";
|
|
221
|
+
copilot: "copilot";
|
|
222
|
+
opencode: "opencode";
|
|
223
|
+
}>>>;
|
|
224
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
225
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
226
|
+
mcp: z.ZodString;
|
|
227
|
+
config: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
228
|
+
env: z.ZodString;
|
|
229
|
+
secret: z.ZodDefault<z.ZodBoolean>;
|
|
230
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
231
|
+
default: z.ZodOptional<z.ZodString>;
|
|
232
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
233
|
+
}, z.core.$strip>>>;
|
|
234
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
235
|
+
claude: "claude";
|
|
236
|
+
codex: "codex";
|
|
237
|
+
cursor: "cursor";
|
|
238
|
+
copilot: "copilot";
|
|
239
|
+
opencode: "opencode";
|
|
240
|
+
}>>>;
|
|
241
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
242
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
243
|
+
agent: z.ZodString;
|
|
244
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
245
|
+
claude: "claude";
|
|
246
|
+
codex: "codex";
|
|
247
|
+
cursor: "cursor";
|
|
248
|
+
copilot: "copilot";
|
|
249
|
+
opencode: "opencode";
|
|
250
|
+
}>>>;
|
|
251
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
252
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
253
|
+
hook: z.ZodString;
|
|
254
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
255
|
+
claude: "claude";
|
|
256
|
+
codex: "codex";
|
|
257
|
+
cursor: "cursor";
|
|
258
|
+
copilot: "copilot";
|
|
259
|
+
opencode: "opencode";
|
|
260
|
+
}>>>;
|
|
261
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
262
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
263
|
+
command: z.ZodString;
|
|
264
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
265
|
+
claude: "claude";
|
|
266
|
+
codex: "codex";
|
|
267
|
+
cursor: "cursor";
|
|
268
|
+
copilot: "copilot";
|
|
269
|
+
opencode: "opencode";
|
|
270
|
+
}>>>;
|
|
271
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
272
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
273
|
+
passthrough: z.ZodString;
|
|
274
|
+
target: z.ZodEnum<{
|
|
275
|
+
claude: "claude";
|
|
276
|
+
codex: "codex";
|
|
277
|
+
cursor: "cursor";
|
|
278
|
+
copilot: "copilot";
|
|
279
|
+
opencode: "opencode";
|
|
280
|
+
}>;
|
|
281
|
+
kind: z.ZodEnum<{
|
|
282
|
+
hook: "hook";
|
|
283
|
+
plugin: "plugin";
|
|
284
|
+
script: "script";
|
|
285
|
+
}>;
|
|
286
|
+
default_enabled: z.ZodDefault<z.ZodBoolean>;
|
|
287
|
+
}, z.core.$strict>]>>;
|
|
288
|
+
depends: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
289
|
+
plugin: z.ZodString;
|
|
290
|
+
version: z.ZodOptional<z.ZodString>;
|
|
291
|
+
components: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
292
|
+
}, z.core.$strip>>>;
|
|
293
|
+
trust: z.ZodOptional<z.ZodObject<{
|
|
294
|
+
sign: z.ZodDefault<z.ZodBoolean>;
|
|
295
|
+
scan: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
296
|
+
schema: "schema";
|
|
297
|
+
security: "security";
|
|
298
|
+
}>>>;
|
|
299
|
+
}, z.core.$strip>>;
|
|
300
|
+
}, z.core.$strip>;
|
|
301
|
+
type Plugin = z.infer<typeof Plugin>;
|
|
302
|
+
|
|
303
|
+
interface DetectedKind {
|
|
304
|
+
kind: ComponentKind;
|
|
305
|
+
}
|
|
306
|
+
/**
|
|
307
|
+
* Decide a component's kind from which discriminating key is present.
|
|
308
|
+
* Returns an error string instead of throwing so callers can attach a path.
|
|
309
|
+
*/
|
|
310
|
+
declare function detectComponentKind(raw: unknown): {
|
|
311
|
+
ok: true;
|
|
312
|
+
kind: ComponentKind;
|
|
313
|
+
} | {
|
|
314
|
+
ok: false;
|
|
315
|
+
error: string;
|
|
316
|
+
};
|
|
317
|
+
/** The schema for a detected kind — used by the loader for path-precise errors. */
|
|
318
|
+
declare function schemaForKind(kind: ComponentKind): zod.ZodObject<{
|
|
319
|
+
skill: zod.ZodString;
|
|
320
|
+
targets: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
|
|
321
|
+
claude: "claude";
|
|
322
|
+
codex: "codex";
|
|
323
|
+
cursor: "cursor";
|
|
324
|
+
copilot: "copilot";
|
|
325
|
+
opencode: "opencode";
|
|
326
|
+
}>>>;
|
|
327
|
+
evals: zod.ZodOptional<zod.ZodString>;
|
|
328
|
+
}, zod_v4_core.$strict> | zod.ZodObject<{
|
|
329
|
+
mcp: zod.ZodString;
|
|
330
|
+
config: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
|
|
331
|
+
env: zod.ZodString;
|
|
332
|
+
secret: zod.ZodDefault<zod.ZodBoolean>;
|
|
333
|
+
prompt: zod.ZodOptional<zod.ZodString>;
|
|
334
|
+
default: zod.ZodOptional<zod.ZodString>;
|
|
335
|
+
required: zod.ZodDefault<zod.ZodBoolean>;
|
|
336
|
+
}, zod_v4_core.$strip>>>;
|
|
337
|
+
targets: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
|
|
338
|
+
claude: "claude";
|
|
339
|
+
codex: "codex";
|
|
340
|
+
cursor: "cursor";
|
|
341
|
+
copilot: "copilot";
|
|
342
|
+
opencode: "opencode";
|
|
343
|
+
}>>>;
|
|
344
|
+
evals: zod.ZodOptional<zod.ZodString>;
|
|
345
|
+
}, zod_v4_core.$strict> | zod.ZodObject<{
|
|
346
|
+
agent: zod.ZodString;
|
|
347
|
+
targets: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
|
|
348
|
+
claude: "claude";
|
|
349
|
+
codex: "codex";
|
|
350
|
+
cursor: "cursor";
|
|
351
|
+
copilot: "copilot";
|
|
352
|
+
opencode: "opencode";
|
|
353
|
+
}>>>;
|
|
354
|
+
evals: zod.ZodOptional<zod.ZodString>;
|
|
355
|
+
}, zod_v4_core.$strict> | zod.ZodObject<{
|
|
356
|
+
hook: zod.ZodString;
|
|
357
|
+
targets: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
|
|
358
|
+
claude: "claude";
|
|
359
|
+
codex: "codex";
|
|
360
|
+
cursor: "cursor";
|
|
361
|
+
copilot: "copilot";
|
|
362
|
+
opencode: "opencode";
|
|
363
|
+
}>>>;
|
|
364
|
+
evals: zod.ZodOptional<zod.ZodString>;
|
|
365
|
+
}, zod_v4_core.$strict> | zod.ZodObject<{
|
|
366
|
+
command: zod.ZodString;
|
|
367
|
+
targets: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
|
|
368
|
+
claude: "claude";
|
|
369
|
+
codex: "codex";
|
|
370
|
+
cursor: "cursor";
|
|
371
|
+
copilot: "copilot";
|
|
372
|
+
opencode: "opencode";
|
|
373
|
+
}>>>;
|
|
374
|
+
evals: zod.ZodOptional<zod.ZodString>;
|
|
375
|
+
}, zod_v4_core.$strict> | zod.ZodObject<{
|
|
376
|
+
passthrough: zod.ZodString;
|
|
377
|
+
target: zod.ZodEnum<{
|
|
378
|
+
claude: "claude";
|
|
379
|
+
codex: "codex";
|
|
380
|
+
cursor: "cursor";
|
|
381
|
+
copilot: "copilot";
|
|
382
|
+
opencode: "opencode";
|
|
383
|
+
}>;
|
|
384
|
+
kind: zod.ZodEnum<{
|
|
385
|
+
hook: "hook";
|
|
386
|
+
plugin: "plugin";
|
|
387
|
+
script: "script";
|
|
388
|
+
}>;
|
|
389
|
+
default_enabled: zod.ZodDefault<zod.ZodBoolean>;
|
|
390
|
+
}, zod_v4_core.$strict>;
|
|
391
|
+
/** The kind of an already-validated component. */
|
|
392
|
+
declare function kindOf(component: Component): ComponentKind;
|
|
393
|
+
/** The relative path (skill dir, mcp dir, hook file, …) this component points at. */
|
|
394
|
+
declare function refOf(component: Component): string;
|
|
395
|
+
/**
|
|
396
|
+
* The leaf name used to build a fully-qualified id `{namespace}/{plugin}:{leaf}`.
|
|
397
|
+
* Derived from the basename of the component's ref, stripping a known extension.
|
|
398
|
+
*/
|
|
399
|
+
declare function leafNameOf(component: Component): string;
|
|
400
|
+
/** Harnesses this component targets, defaulting to all when unspecified. */
|
|
401
|
+
declare function targetsOf(component: Component, all: readonly string[]): readonly string[];
|
|
402
|
+
/** Build the canonical fully-qualified id for a component. */
|
|
403
|
+
declare function fqid(namespace: string, bundleName: string, leaf: string): string;
|
|
404
|
+
|
|
405
|
+
declare const TraceAssert: z.ZodObject<{
|
|
406
|
+
kind: z.ZodLiteral<"trace">;
|
|
407
|
+
toolCalled: z.ZodOptional<z.ZodString>;
|
|
408
|
+
toolNotCalled: z.ZodOptional<z.ZodString>;
|
|
409
|
+
sequence: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
410
|
+
maxCalls: z.ZodOptional<z.ZodNumber>;
|
|
411
|
+
minPassRate: z.ZodDefault<z.ZodNumber>;
|
|
412
|
+
}, z.core.$strip>;
|
|
413
|
+
type TraceAssert = z.infer<typeof TraceAssert>;
|
|
414
|
+
declare const OutputAssert: z.ZodObject<{
|
|
415
|
+
kind: z.ZodLiteral<"output">;
|
|
416
|
+
equals: z.ZodOptional<z.ZodString>;
|
|
417
|
+
matches: z.ZodOptional<z.ZodString>;
|
|
418
|
+
jsonSchema: z.ZodOptional<z.ZodString>;
|
|
419
|
+
tolerance: z.ZodOptional<z.ZodNumber>;
|
|
420
|
+
}, z.core.$strip>;
|
|
421
|
+
type OutputAssert = z.infer<typeof OutputAssert>;
|
|
422
|
+
declare const JudgeAssert: z.ZodObject<{
|
|
423
|
+
kind: z.ZodLiteral<"judge">;
|
|
424
|
+
rubric: z.ZodString;
|
|
425
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
426
|
+
absolute: "absolute";
|
|
427
|
+
pairwise: "pairwise";
|
|
428
|
+
}>>;
|
|
429
|
+
reference: z.ZodOptional<z.ZodString>;
|
|
430
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
431
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
432
|
+
gate: z.ZodDefault<z.ZodBoolean>;
|
|
433
|
+
}, z.core.$strip>;
|
|
434
|
+
type JudgeAssert = z.infer<typeof JudgeAssert>;
|
|
435
|
+
declare const DifferentialAssert: z.ZodObject<{
|
|
436
|
+
kind: z.ZodLiteral<"differential">;
|
|
437
|
+
baseline: z.ZodDefault<z.ZodString>;
|
|
438
|
+
noWorseThan: z.ZodDefault<z.ZodNumber>;
|
|
439
|
+
}, z.core.$strip>;
|
|
440
|
+
type DifferentialAssert = z.infer<typeof DifferentialAssert>;
|
|
441
|
+
declare const Assertion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
442
|
+
kind: z.ZodLiteral<"trace">;
|
|
443
|
+
toolCalled: z.ZodOptional<z.ZodString>;
|
|
444
|
+
toolNotCalled: z.ZodOptional<z.ZodString>;
|
|
445
|
+
sequence: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
446
|
+
maxCalls: z.ZodOptional<z.ZodNumber>;
|
|
447
|
+
minPassRate: z.ZodDefault<z.ZodNumber>;
|
|
448
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
449
|
+
kind: z.ZodLiteral<"output">;
|
|
450
|
+
equals: z.ZodOptional<z.ZodString>;
|
|
451
|
+
matches: z.ZodOptional<z.ZodString>;
|
|
452
|
+
jsonSchema: z.ZodOptional<z.ZodString>;
|
|
453
|
+
tolerance: z.ZodOptional<z.ZodNumber>;
|
|
454
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
455
|
+
kind: z.ZodLiteral<"judge">;
|
|
456
|
+
rubric: z.ZodString;
|
|
457
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
458
|
+
absolute: "absolute";
|
|
459
|
+
pairwise: "pairwise";
|
|
460
|
+
}>>;
|
|
461
|
+
reference: z.ZodOptional<z.ZodString>;
|
|
462
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
463
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
464
|
+
gate: z.ZodDefault<z.ZodBoolean>;
|
|
465
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
466
|
+
kind: z.ZodLiteral<"differential">;
|
|
467
|
+
baseline: z.ZodDefault<z.ZodString>;
|
|
468
|
+
noWorseThan: z.ZodDefault<z.ZodNumber>;
|
|
469
|
+
}, z.core.$strip>], "kind">;
|
|
470
|
+
type Assertion = z.infer<typeof Assertion>;
|
|
471
|
+
declare const Case: z.ZodObject<{
|
|
472
|
+
name: z.ZodString;
|
|
473
|
+
prompt: z.ZodString;
|
|
474
|
+
setup: z.ZodOptional<z.ZodString>;
|
|
475
|
+
verify: z.ZodOptional<z.ZodString>;
|
|
476
|
+
cleanup: z.ZodOptional<z.ZodString>;
|
|
477
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
478
|
+
assert: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
479
|
+
kind: z.ZodLiteral<"trace">;
|
|
480
|
+
toolCalled: z.ZodOptional<z.ZodString>;
|
|
481
|
+
toolNotCalled: z.ZodOptional<z.ZodString>;
|
|
482
|
+
sequence: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
483
|
+
maxCalls: z.ZodOptional<z.ZodNumber>;
|
|
484
|
+
minPassRate: z.ZodDefault<z.ZodNumber>;
|
|
485
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
486
|
+
kind: z.ZodLiteral<"output">;
|
|
487
|
+
equals: z.ZodOptional<z.ZodString>;
|
|
488
|
+
matches: z.ZodOptional<z.ZodString>;
|
|
489
|
+
jsonSchema: z.ZodOptional<z.ZodString>;
|
|
490
|
+
tolerance: z.ZodOptional<z.ZodNumber>;
|
|
491
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
492
|
+
kind: z.ZodLiteral<"judge">;
|
|
493
|
+
rubric: z.ZodString;
|
|
494
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
495
|
+
absolute: "absolute";
|
|
496
|
+
pairwise: "pairwise";
|
|
497
|
+
}>>;
|
|
498
|
+
reference: z.ZodOptional<z.ZodString>;
|
|
499
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
500
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
501
|
+
gate: z.ZodDefault<z.ZodBoolean>;
|
|
502
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
503
|
+
kind: z.ZodLiteral<"differential">;
|
|
504
|
+
baseline: z.ZodDefault<z.ZodString>;
|
|
505
|
+
noWorseThan: z.ZodDefault<z.ZodNumber>;
|
|
506
|
+
}, z.core.$strip>], "kind">>;
|
|
507
|
+
}, z.core.$strip>;
|
|
508
|
+
type Case = z.infer<typeof Case>;
|
|
509
|
+
/** `cases.yaml` — evals for one component. */
|
|
510
|
+
declare const EvalFile: z.ZodObject<{
|
|
511
|
+
component: z.ZodString;
|
|
512
|
+
harnesses: z.ZodArray<z.ZodEnum<{
|
|
513
|
+
claude: "claude";
|
|
514
|
+
codex: "codex";
|
|
515
|
+
cursor: "cursor";
|
|
516
|
+
copilot: "copilot";
|
|
517
|
+
opencode: "opencode";
|
|
518
|
+
}>>;
|
|
519
|
+
cases: z.ZodArray<z.ZodObject<{
|
|
520
|
+
name: z.ZodString;
|
|
521
|
+
prompt: z.ZodString;
|
|
522
|
+
setup: z.ZodOptional<z.ZodString>;
|
|
523
|
+
verify: z.ZodOptional<z.ZodString>;
|
|
524
|
+
cleanup: z.ZodOptional<z.ZodString>;
|
|
525
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
526
|
+
assert: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
527
|
+
kind: z.ZodLiteral<"trace">;
|
|
528
|
+
toolCalled: z.ZodOptional<z.ZodString>;
|
|
529
|
+
toolNotCalled: z.ZodOptional<z.ZodString>;
|
|
530
|
+
sequence: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
531
|
+
maxCalls: z.ZodOptional<z.ZodNumber>;
|
|
532
|
+
minPassRate: z.ZodDefault<z.ZodNumber>;
|
|
533
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
534
|
+
kind: z.ZodLiteral<"output">;
|
|
535
|
+
equals: z.ZodOptional<z.ZodString>;
|
|
536
|
+
matches: z.ZodOptional<z.ZodString>;
|
|
537
|
+
jsonSchema: z.ZodOptional<z.ZodString>;
|
|
538
|
+
tolerance: z.ZodOptional<z.ZodNumber>;
|
|
539
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
540
|
+
kind: z.ZodLiteral<"judge">;
|
|
541
|
+
rubric: z.ZodString;
|
|
542
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
543
|
+
absolute: "absolute";
|
|
544
|
+
pairwise: "pairwise";
|
|
545
|
+
}>>;
|
|
546
|
+
reference: z.ZodOptional<z.ZodString>;
|
|
547
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
548
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
549
|
+
gate: z.ZodDefault<z.ZodBoolean>;
|
|
550
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
551
|
+
kind: z.ZodLiteral<"differential">;
|
|
552
|
+
baseline: z.ZodDefault<z.ZodString>;
|
|
553
|
+
noWorseThan: z.ZodDefault<z.ZodNumber>;
|
|
554
|
+
}, z.core.$strip>], "kind">>;
|
|
555
|
+
}, z.core.$strip>>;
|
|
556
|
+
}, z.core.$strip>;
|
|
557
|
+
type EvalFile = z.infer<typeof EvalFile>;
|
|
558
|
+
|
|
559
|
+
/** Trust badges (spec §10). valid/tested are computed in Phase 2; the rest in Phase 3. */
|
|
560
|
+
declare const Badge: z.ZodEnum<{
|
|
561
|
+
valid: "valid";
|
|
562
|
+
tested: "tested";
|
|
563
|
+
verified: "verified";
|
|
564
|
+
scanned: "scanned";
|
|
565
|
+
signed: "signed";
|
|
566
|
+
}>;
|
|
567
|
+
type Badge = z.infer<typeof Badge>;
|
|
568
|
+
declare const IndexVersion: z.ZodObject<{
|
|
569
|
+
version: z.ZodString;
|
|
570
|
+
ref: z.ZodString;
|
|
571
|
+
sha: z.ZodString;
|
|
572
|
+
badges: z.ZodArray<z.ZodEnum<{
|
|
573
|
+
valid: "valid";
|
|
574
|
+
tested: "tested";
|
|
575
|
+
verified: "verified";
|
|
576
|
+
scanned: "scanned";
|
|
577
|
+
signed: "signed";
|
|
578
|
+
}>>;
|
|
579
|
+
harnessCoverage: z.ZodArray<z.ZodEnum<{
|
|
580
|
+
claude: "claude";
|
|
581
|
+
codex: "codex";
|
|
582
|
+
cursor: "cursor";
|
|
583
|
+
copilot: "copilot";
|
|
584
|
+
opencode: "opencode";
|
|
585
|
+
}>>;
|
|
586
|
+
}, z.core.$strip>;
|
|
587
|
+
type IndexVersion = z.infer<typeof IndexVersion>;
|
|
588
|
+
declare const IndexEntry: z.ZodObject<{
|
|
589
|
+
id: z.ZodString;
|
|
590
|
+
source: z.ZodString;
|
|
591
|
+
versions: z.ZodArray<z.ZodObject<{
|
|
592
|
+
version: z.ZodString;
|
|
593
|
+
ref: z.ZodString;
|
|
594
|
+
sha: z.ZodString;
|
|
595
|
+
badges: z.ZodArray<z.ZodEnum<{
|
|
596
|
+
valid: "valid";
|
|
597
|
+
tested: "tested";
|
|
598
|
+
verified: "verified";
|
|
599
|
+
scanned: "scanned";
|
|
600
|
+
signed: "signed";
|
|
601
|
+
}>>;
|
|
602
|
+
harnessCoverage: z.ZodArray<z.ZodEnum<{
|
|
603
|
+
claude: "claude";
|
|
604
|
+
codex: "codex";
|
|
605
|
+
cursor: "cursor";
|
|
606
|
+
copilot: "copilot";
|
|
607
|
+
opencode: "opencode";
|
|
608
|
+
}>>;
|
|
609
|
+
}, z.core.$strip>>;
|
|
610
|
+
telemetry: z.ZodOptional<z.ZodObject<{
|
|
611
|
+
installs: z.ZodDefault<z.ZodNumber>;
|
|
612
|
+
activeUsage: z.ZodDefault<z.ZodNumber>;
|
|
613
|
+
}, z.core.$strip>>;
|
|
614
|
+
}, z.core.$strip>;
|
|
615
|
+
type IndexEntry = z.infer<typeof IndexEntry>;
|
|
616
|
+
/** `loom.index/1` -- a metadata-only aggregator (spec §10), self-hostable static JSON. */
|
|
617
|
+
declare const IndexFile: z.ZodObject<{
|
|
618
|
+
schema: z.ZodLiteral<"loom.index/1">;
|
|
619
|
+
plugins: z.ZodArray<z.ZodObject<{
|
|
620
|
+
id: z.ZodString;
|
|
621
|
+
source: z.ZodString;
|
|
622
|
+
versions: z.ZodArray<z.ZodObject<{
|
|
623
|
+
version: z.ZodString;
|
|
624
|
+
ref: z.ZodString;
|
|
625
|
+
sha: z.ZodString;
|
|
626
|
+
badges: z.ZodArray<z.ZodEnum<{
|
|
627
|
+
valid: "valid";
|
|
628
|
+
tested: "tested";
|
|
629
|
+
verified: "verified";
|
|
630
|
+
scanned: "scanned";
|
|
631
|
+
signed: "signed";
|
|
632
|
+
}>>;
|
|
633
|
+
harnessCoverage: z.ZodArray<z.ZodEnum<{
|
|
634
|
+
claude: "claude";
|
|
635
|
+
codex: "codex";
|
|
636
|
+
cursor: "cursor";
|
|
637
|
+
copilot: "copilot";
|
|
638
|
+
opencode: "opencode";
|
|
639
|
+
}>>;
|
|
640
|
+
}, z.core.$strip>>;
|
|
641
|
+
telemetry: z.ZodOptional<z.ZodObject<{
|
|
642
|
+
installs: z.ZodDefault<z.ZodNumber>;
|
|
643
|
+
activeUsage: z.ZodDefault<z.ZodNumber>;
|
|
644
|
+
}, z.core.$strip>>;
|
|
645
|
+
}, z.core.$strip>>;
|
|
646
|
+
federated: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
647
|
+
source: z.ZodString;
|
|
648
|
+
ingestedAt: z.ZodString;
|
|
649
|
+
}, z.core.$strip>>>;
|
|
650
|
+
}, z.core.$strip>;
|
|
651
|
+
type IndexFile = z.infer<typeof IndexFile>;
|
|
652
|
+
|
|
653
|
+
/** Canonical manifests for which we publish a `$schema` for editor autocomplete. */
|
|
654
|
+
declare const SCHEMAS: {
|
|
655
|
+
readonly "loom.yaml": z.ZodObject<{
|
|
656
|
+
name: z.ZodString;
|
|
657
|
+
version: z.ZodString;
|
|
658
|
+
owner: z.ZodObject<{
|
|
659
|
+
name: z.ZodString;
|
|
660
|
+
namespace: z.ZodString;
|
|
661
|
+
email: z.ZodOptional<z.ZodEmail>;
|
|
662
|
+
}, z.core.$strip>;
|
|
663
|
+
description: z.ZodOptional<z.ZodString>;
|
|
664
|
+
license: z.ZodOptional<z.ZodString>;
|
|
665
|
+
loom_min_version: z.ZodOptional<z.ZodString>;
|
|
666
|
+
components: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
|
|
667
|
+
skill: z.ZodString;
|
|
668
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
669
|
+
claude: "claude";
|
|
670
|
+
codex: "codex";
|
|
671
|
+
cursor: "cursor";
|
|
672
|
+
copilot: "copilot";
|
|
673
|
+
opencode: "opencode";
|
|
674
|
+
}>>>;
|
|
675
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
676
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
677
|
+
mcp: z.ZodString;
|
|
678
|
+
config: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
679
|
+
env: z.ZodString;
|
|
680
|
+
secret: z.ZodDefault<z.ZodBoolean>;
|
|
681
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
682
|
+
default: z.ZodOptional<z.ZodString>;
|
|
683
|
+
required: z.ZodDefault<z.ZodBoolean>;
|
|
684
|
+
}, z.core.$strip>>>;
|
|
685
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
686
|
+
claude: "claude";
|
|
687
|
+
codex: "codex";
|
|
688
|
+
cursor: "cursor";
|
|
689
|
+
copilot: "copilot";
|
|
690
|
+
opencode: "opencode";
|
|
691
|
+
}>>>;
|
|
692
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
693
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
694
|
+
agent: z.ZodString;
|
|
695
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
696
|
+
claude: "claude";
|
|
697
|
+
codex: "codex";
|
|
698
|
+
cursor: "cursor";
|
|
699
|
+
copilot: "copilot";
|
|
700
|
+
opencode: "opencode";
|
|
701
|
+
}>>>;
|
|
702
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
703
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
704
|
+
hook: z.ZodString;
|
|
705
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
706
|
+
claude: "claude";
|
|
707
|
+
codex: "codex";
|
|
708
|
+
cursor: "cursor";
|
|
709
|
+
copilot: "copilot";
|
|
710
|
+
opencode: "opencode";
|
|
711
|
+
}>>>;
|
|
712
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
713
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
714
|
+
command: z.ZodString;
|
|
715
|
+
targets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
716
|
+
claude: "claude";
|
|
717
|
+
codex: "codex";
|
|
718
|
+
cursor: "cursor";
|
|
719
|
+
copilot: "copilot";
|
|
720
|
+
opencode: "opencode";
|
|
721
|
+
}>>>;
|
|
722
|
+
evals: z.ZodOptional<z.ZodString>;
|
|
723
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
724
|
+
passthrough: z.ZodString;
|
|
725
|
+
target: z.ZodEnum<{
|
|
726
|
+
claude: "claude";
|
|
727
|
+
codex: "codex";
|
|
728
|
+
cursor: "cursor";
|
|
729
|
+
copilot: "copilot";
|
|
730
|
+
opencode: "opencode";
|
|
731
|
+
}>;
|
|
732
|
+
kind: z.ZodEnum<{
|
|
733
|
+
hook: "hook";
|
|
734
|
+
plugin: "plugin";
|
|
735
|
+
script: "script";
|
|
736
|
+
}>;
|
|
737
|
+
default_enabled: z.ZodDefault<z.ZodBoolean>;
|
|
738
|
+
}, z.core.$strict>]>>;
|
|
739
|
+
depends: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
740
|
+
plugin: z.ZodString;
|
|
741
|
+
version: z.ZodOptional<z.ZodString>;
|
|
742
|
+
components: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
743
|
+
}, z.core.$strip>>>;
|
|
744
|
+
trust: z.ZodOptional<z.ZodObject<{
|
|
745
|
+
sign: z.ZodDefault<z.ZodBoolean>;
|
|
746
|
+
scan: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
747
|
+
schema: "schema";
|
|
748
|
+
security: "security";
|
|
749
|
+
}>>>;
|
|
750
|
+
}, z.core.$strip>>;
|
|
751
|
+
}, z.core.$strip>;
|
|
752
|
+
readonly "marketplace.yaml": z.ZodObject<{
|
|
753
|
+
name: z.ZodString;
|
|
754
|
+
owner: z.ZodObject<{
|
|
755
|
+
name: z.ZodString;
|
|
756
|
+
namespace: z.ZodString;
|
|
757
|
+
email: z.ZodOptional<z.ZodEmail>;
|
|
758
|
+
}, z.core.$strip>;
|
|
759
|
+
description: z.ZodOptional<z.ZodString>;
|
|
760
|
+
plugins: z.ZodArray<z.ZodObject<{
|
|
761
|
+
plugin: z.ZodString;
|
|
762
|
+
version: z.ZodOptional<z.ZodString>;
|
|
763
|
+
category: z.ZodOptional<z.ZodString>;
|
|
764
|
+
tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
765
|
+
}, z.core.$strip>>;
|
|
766
|
+
allow_dependencies_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
767
|
+
}, z.core.$strip>;
|
|
768
|
+
readonly "loom.lock": z.ZodObject<{
|
|
769
|
+
loomVersion: z.ZodString;
|
|
770
|
+
generatedAt: z.ZodString;
|
|
771
|
+
plugin: z.ZodObject<{
|
|
772
|
+
id: z.ZodString;
|
|
773
|
+
version: z.ZodString;
|
|
774
|
+
ref: z.ZodString;
|
|
775
|
+
sha: z.ZodString;
|
|
776
|
+
}, z.core.$strip>;
|
|
777
|
+
dependencies: z.ZodArray<z.ZodObject<{
|
|
778
|
+
id: z.ZodString;
|
|
779
|
+
range: z.ZodString;
|
|
780
|
+
resolvedSha: z.ZodString;
|
|
781
|
+
}, z.core.$strip>>;
|
|
782
|
+
artifacts: z.ZodArray<z.ZodObject<{
|
|
783
|
+
component: z.ZodString;
|
|
784
|
+
target: z.ZodEnum<{
|
|
785
|
+
claude: "claude";
|
|
786
|
+
codex: "codex";
|
|
787
|
+
cursor: "cursor";
|
|
788
|
+
copilot: "copilot";
|
|
789
|
+
opencode: "opencode";
|
|
790
|
+
}>;
|
|
791
|
+
scope: z.ZodEnum<{
|
|
792
|
+
user: "user";
|
|
793
|
+
project: "project";
|
|
794
|
+
}>;
|
|
795
|
+
path: z.ZodString;
|
|
796
|
+
hash: z.ZodString;
|
|
797
|
+
placement: z.ZodEnum<{
|
|
798
|
+
copy: "copy";
|
|
799
|
+
shared: "shared";
|
|
800
|
+
}>;
|
|
801
|
+
enabled: z.ZodBoolean;
|
|
802
|
+
}, z.core.$strip>>;
|
|
803
|
+
adapters: z.ZodObject<{
|
|
804
|
+
claude: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
805
|
+
version: z.ZodString;
|
|
806
|
+
targetSchema: z.ZodString;
|
|
807
|
+
}, z.core.$strip>>>;
|
|
808
|
+
codex: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
809
|
+
version: z.ZodString;
|
|
810
|
+
targetSchema: z.ZodString;
|
|
811
|
+
}, z.core.$strip>>>;
|
|
812
|
+
cursor: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
813
|
+
version: z.ZodString;
|
|
814
|
+
targetSchema: z.ZodString;
|
|
815
|
+
}, z.core.$strip>>>;
|
|
816
|
+
copilot: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
817
|
+
version: z.ZodString;
|
|
818
|
+
targetSchema: z.ZodString;
|
|
819
|
+
}, z.core.$strip>>>;
|
|
820
|
+
opencode: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
821
|
+
version: z.ZodString;
|
|
822
|
+
targetSchema: z.ZodString;
|
|
823
|
+
}, z.core.$strip>>>;
|
|
824
|
+
}, z.core.$strip>;
|
|
825
|
+
aliases: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
826
|
+
}, z.core.$strip>;
|
|
827
|
+
readonly "cases.yaml": z.ZodObject<{
|
|
828
|
+
component: z.ZodString;
|
|
829
|
+
harnesses: z.ZodArray<z.ZodEnum<{
|
|
830
|
+
claude: "claude";
|
|
831
|
+
codex: "codex";
|
|
832
|
+
cursor: "cursor";
|
|
833
|
+
copilot: "copilot";
|
|
834
|
+
opencode: "opencode";
|
|
835
|
+
}>>;
|
|
836
|
+
cases: z.ZodArray<z.ZodObject<{
|
|
837
|
+
name: z.ZodString;
|
|
838
|
+
prompt: z.ZodString;
|
|
839
|
+
setup: z.ZodOptional<z.ZodString>;
|
|
840
|
+
verify: z.ZodOptional<z.ZodString>;
|
|
841
|
+
cleanup: z.ZodOptional<z.ZodString>;
|
|
842
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
843
|
+
assert: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
844
|
+
kind: z.ZodLiteral<"trace">;
|
|
845
|
+
toolCalled: z.ZodOptional<z.ZodString>;
|
|
846
|
+
toolNotCalled: z.ZodOptional<z.ZodString>;
|
|
847
|
+
sequence: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
848
|
+
maxCalls: z.ZodOptional<z.ZodNumber>;
|
|
849
|
+
minPassRate: z.ZodDefault<z.ZodNumber>;
|
|
850
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
851
|
+
kind: z.ZodLiteral<"output">;
|
|
852
|
+
equals: z.ZodOptional<z.ZodString>;
|
|
853
|
+
matches: z.ZodOptional<z.ZodString>;
|
|
854
|
+
jsonSchema: z.ZodOptional<z.ZodString>;
|
|
855
|
+
tolerance: z.ZodOptional<z.ZodNumber>;
|
|
856
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
857
|
+
kind: z.ZodLiteral<"judge">;
|
|
858
|
+
rubric: z.ZodString;
|
|
859
|
+
mode: z.ZodDefault<z.ZodEnum<{
|
|
860
|
+
absolute: "absolute";
|
|
861
|
+
pairwise: "pairwise";
|
|
862
|
+
}>>;
|
|
863
|
+
reference: z.ZodOptional<z.ZodString>;
|
|
864
|
+
samples: z.ZodDefault<z.ZodNumber>;
|
|
865
|
+
threshold: z.ZodOptional<z.ZodNumber>;
|
|
866
|
+
gate: z.ZodDefault<z.ZodBoolean>;
|
|
867
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
868
|
+
kind: z.ZodLiteral<"differential">;
|
|
869
|
+
baseline: z.ZodDefault<z.ZodString>;
|
|
870
|
+
noWorseThan: z.ZodDefault<z.ZodNumber>;
|
|
871
|
+
}, z.core.$strip>], "kind">>;
|
|
872
|
+
}, z.core.$strip>>;
|
|
873
|
+
}, z.core.$strip>;
|
|
874
|
+
};
|
|
875
|
+
type SchemaName = keyof typeof SCHEMAS;
|
|
876
|
+
/** Export a JSON Schema (draft 2020-12) for one canonical manifest. */
|
|
877
|
+
declare function jsonSchemaFor(name: SchemaName): unknown;
|
|
878
|
+
/** Export JSON Schemas for every canonical manifest, keyed by file name. */
|
|
879
|
+
declare function allJsonSchemas(): Record<SchemaName, unknown>;
|
|
880
|
+
|
|
881
|
+
declare const Scope: z.ZodEnum<{
|
|
882
|
+
user: "user";
|
|
883
|
+
project: "project";
|
|
884
|
+
}>;
|
|
885
|
+
type Scope = z.infer<typeof Scope>;
|
|
886
|
+
declare const ArtifactRecord: z.ZodObject<{
|
|
887
|
+
component: z.ZodString;
|
|
888
|
+
target: z.ZodEnum<{
|
|
889
|
+
claude: "claude";
|
|
890
|
+
codex: "codex";
|
|
891
|
+
cursor: "cursor";
|
|
892
|
+
copilot: "copilot";
|
|
893
|
+
opencode: "opencode";
|
|
894
|
+
}>;
|
|
895
|
+
scope: z.ZodEnum<{
|
|
896
|
+
user: "user";
|
|
897
|
+
project: "project";
|
|
898
|
+
}>;
|
|
899
|
+
path: z.ZodString;
|
|
900
|
+
hash: z.ZodString;
|
|
901
|
+
placement: z.ZodEnum<{
|
|
902
|
+
copy: "copy";
|
|
903
|
+
shared: "shared";
|
|
904
|
+
}>;
|
|
905
|
+
enabled: z.ZodBoolean;
|
|
906
|
+
}, z.core.$strip>;
|
|
907
|
+
type ArtifactRecord = z.infer<typeof ArtifactRecord>;
|
|
908
|
+
declare const AdapterRecord: z.ZodObject<{
|
|
909
|
+
version: z.ZodString;
|
|
910
|
+
targetSchema: z.ZodString;
|
|
911
|
+
}, z.core.$strip>;
|
|
912
|
+
/** `loom.lock` — generated and committed; drives update/uninstall/verify. */
|
|
913
|
+
declare const Lockfile: z.ZodObject<{
|
|
914
|
+
loomVersion: z.ZodString;
|
|
915
|
+
generatedAt: z.ZodString;
|
|
916
|
+
plugin: z.ZodObject<{
|
|
917
|
+
id: z.ZodString;
|
|
918
|
+
version: z.ZodString;
|
|
919
|
+
ref: z.ZodString;
|
|
920
|
+
sha: z.ZodString;
|
|
921
|
+
}, z.core.$strip>;
|
|
922
|
+
dependencies: z.ZodArray<z.ZodObject<{
|
|
923
|
+
id: z.ZodString;
|
|
924
|
+
range: z.ZodString;
|
|
925
|
+
resolvedSha: z.ZodString;
|
|
926
|
+
}, z.core.$strip>>;
|
|
927
|
+
artifacts: z.ZodArray<z.ZodObject<{
|
|
928
|
+
component: z.ZodString;
|
|
929
|
+
target: z.ZodEnum<{
|
|
930
|
+
claude: "claude";
|
|
931
|
+
codex: "codex";
|
|
932
|
+
cursor: "cursor";
|
|
933
|
+
copilot: "copilot";
|
|
934
|
+
opencode: "opencode";
|
|
935
|
+
}>;
|
|
936
|
+
scope: z.ZodEnum<{
|
|
937
|
+
user: "user";
|
|
938
|
+
project: "project";
|
|
939
|
+
}>;
|
|
940
|
+
path: z.ZodString;
|
|
941
|
+
hash: z.ZodString;
|
|
942
|
+
placement: z.ZodEnum<{
|
|
943
|
+
copy: "copy";
|
|
944
|
+
shared: "shared";
|
|
945
|
+
}>;
|
|
946
|
+
enabled: z.ZodBoolean;
|
|
947
|
+
}, z.core.$strip>>;
|
|
948
|
+
adapters: z.ZodObject<{
|
|
949
|
+
claude: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
950
|
+
version: z.ZodString;
|
|
951
|
+
targetSchema: z.ZodString;
|
|
952
|
+
}, z.core.$strip>>>;
|
|
953
|
+
codex: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
954
|
+
version: z.ZodString;
|
|
955
|
+
targetSchema: z.ZodString;
|
|
956
|
+
}, z.core.$strip>>>;
|
|
957
|
+
cursor: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
958
|
+
version: z.ZodString;
|
|
959
|
+
targetSchema: z.ZodString;
|
|
960
|
+
}, z.core.$strip>>>;
|
|
961
|
+
copilot: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
962
|
+
version: z.ZodString;
|
|
963
|
+
targetSchema: z.ZodString;
|
|
964
|
+
}, z.core.$strip>>>;
|
|
965
|
+
opencode: z.ZodOptional<z.ZodOptional<z.ZodObject<{
|
|
966
|
+
version: z.ZodString;
|
|
967
|
+
targetSchema: z.ZodString;
|
|
968
|
+
}, z.core.$strip>>>;
|
|
969
|
+
}, z.core.$strip>;
|
|
970
|
+
aliases: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
971
|
+
}, z.core.$strip>;
|
|
972
|
+
type Lockfile = z.infer<typeof Lockfile>;
|
|
973
|
+
|
|
974
|
+
declare const MarketplaceEntry: z.ZodObject<{
|
|
975
|
+
plugin: z.ZodString;
|
|
976
|
+
version: z.ZodOptional<z.ZodString>;
|
|
977
|
+
category: z.ZodOptional<z.ZodString>;
|
|
978
|
+
tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
979
|
+
}, z.core.$strip>;
|
|
980
|
+
type MarketplaceEntry = z.infer<typeof MarketplaceEntry>;
|
|
981
|
+
/** `marketplace.yaml` — a curated catalog compiled to each harness's native form. */
|
|
982
|
+
declare const Marketplace: z.ZodObject<{
|
|
983
|
+
name: z.ZodString;
|
|
984
|
+
owner: z.ZodObject<{
|
|
985
|
+
name: z.ZodString;
|
|
986
|
+
namespace: z.ZodString;
|
|
987
|
+
email: z.ZodOptional<z.ZodEmail>;
|
|
988
|
+
}, z.core.$strip>;
|
|
989
|
+
description: z.ZodOptional<z.ZodString>;
|
|
990
|
+
plugins: z.ZodArray<z.ZodObject<{
|
|
991
|
+
plugin: z.ZodString;
|
|
992
|
+
version: z.ZodOptional<z.ZodString>;
|
|
993
|
+
category: z.ZodOptional<z.ZodString>;
|
|
994
|
+
tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
995
|
+
}, z.core.$strip>>;
|
|
996
|
+
allow_dependencies_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
997
|
+
}, z.core.$strip>;
|
|
998
|
+
type Marketplace = z.infer<typeof Marketplace>;
|
|
999
|
+
|
|
1000
|
+
type DocFormat = "yaml" | "json5" | "auto";
|
|
1001
|
+
interface ParseIssue {
|
|
1002
|
+
path: string;
|
|
1003
|
+
message: string;
|
|
1004
|
+
}
|
|
1005
|
+
type ParseResult<T> = {
|
|
1006
|
+
ok: true;
|
|
1007
|
+
value: T;
|
|
1008
|
+
} | {
|
|
1009
|
+
ok: false;
|
|
1010
|
+
issues: ParseIssue[];
|
|
1011
|
+
};
|
|
1012
|
+
/**
|
|
1013
|
+
* Read raw manifest text into a plain object.
|
|
1014
|
+
*
|
|
1015
|
+
* YAML is parsed in **1.2 core** mode, which kills the "Norway problem": only
|
|
1016
|
+
* `true`/`false` are booleans, so `no`/`yes`/`on`/`off` stay strings. (Unquoted
|
|
1017
|
+
* `1.10` still becomes the float `1.1` per YAML semantics — but version fields
|
|
1018
|
+
* are typed as strings, so that surfaces as a precise Zod error telling the
|
|
1019
|
+
* author to quote it.) `strict` rejects duplicate keys. JSON5 input is accepted
|
|
1020
|
+
* against the same schemas.
|
|
1021
|
+
*/
|
|
1022
|
+
declare function parseDocument(text: string, format?: DocFormat, filename?: string): unknown;
|
|
1023
|
+
/** Serialize an object back to YAML 1.2 (used when writing a generated manifest). */
|
|
1024
|
+
declare function stringifyDocument(obj: unknown): string;
|
|
1025
|
+
/** Validate an already-parsed object against a schema, returning path-precise issues. */
|
|
1026
|
+
declare function validate<T>(schema: z.ZodType<T>, raw: unknown): ParseResult<T>;
|
|
1027
|
+
/**
|
|
1028
|
+
* Parse a plugin with kind-aware component routing, so a malformed component
|
|
1029
|
+
* produces `components[2].mcp: Required` rather than a noisy union error.
|
|
1030
|
+
*/
|
|
1031
|
+
declare function parsePlugin(raw: unknown): ParseResult<Plugin>;
|
|
1032
|
+
/** Convenience: read text (YAML/JSON5) and validate against any schema. */
|
|
1033
|
+
declare function loadManifest<T>(schema: z.ZodType<T>, text: string, opts?: {
|
|
1034
|
+
format?: DocFormat;
|
|
1035
|
+
filename?: string;
|
|
1036
|
+
}): ParseResult<T>;
|
|
1037
|
+
/** Read text (YAML/JSON5) and parse as a plugin with component routing. */
|
|
1038
|
+
declare function loadPlugin(text: string, opts?: {
|
|
1039
|
+
format?: DocFormat;
|
|
1040
|
+
filename?: string;
|
|
1041
|
+
}): ParseResult<Plugin>;
|
|
1042
|
+
|
|
1043
|
+
export { ALL_TARGETS, AdapterRecord, AgentComponent, ArtifactRecord, Assertion, Badge, COMPONENT_KINDS, Case, CommandComponent, Component, type ComponentKind, ConfigVar, Dependency, type DetectedKind, DifferentialAssert, type DocFormat, EvalFile, HookComponent, IndexEntry, IndexFile, IndexVersion, JudgeAssert, Lockfile, Marketplace, MarketplaceEntry, McpComponent, Namespace, OutputAssert, Owner, type ParseIssue, type ParseResult, PassthroughComponent, Plugin, SCHEMAS, type SchemaName, Scope, SkillComponent, Target, TraceAssert, Trust, allJsonSchemas, detectComponentKind, fqid, jsonSchemaFor, kindOf, leafNameOf, loadManifest, loadPlugin, parseDocument, parsePlugin, refOf, schemaForKind, stringifyDocument, targetsOf, validate };
|