@matchbox-ai/train 0.1.0

package/dist/models/sequence/fit-sequence.d.ts

@@ -0,0 +1,139 @@
+import type { SequenceArtifact } from "@matchbox-ai/core/internal";
+import type { DatasetExample } from "@matchbox-ai/core";
+import type { SequenceRecipe } from "./types.js";
+export declare function fitSequence(examples: readonly DatasetExample<unknown>[], recipe: SequenceRecipe, metadata: Pick<SequenceArtifact, "taskModule" | "taskMetadata" | "decoderModule">, probes?: readonly string[], shuffleLabels?: boolean, progress?: (epoch: number, loss: number) => void): Promise<{
+    untrained: {
+        formatVersion: 2;
+        modelTopology: Record<string, unknown>;
+        kind: "sequence-parser";
+        architecture: "embedding-window-mlp";
+        taskModule: string;
+        decoderModule: string;
+        taskMetadata: unknown;
+        readout: "all" | "last";
+        tokenizer: "characters" | "words";
+        vocabulary: string[];
+        labels: string[];
+        radius: number;
+        threshold: number;
+        precision: "float32" | "int8";
+        weights: [{
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }];
+    };
+    float: {
+        formatVersion: 2;
+        modelTopology: Record<string, unknown>;
+        kind: "sequence-parser";
+        architecture: "embedding-window-mlp";
+        taskModule: string;
+        decoderModule: string;
+        taskMetadata: unknown;
+        readout: "all" | "last";
+        tokenizer: "characters" | "words";
+        vocabulary: string[];
+        labels: string[];
+        radius: number;
+        threshold: number;
+        precision: "float32" | "int8";
+        weights: [{
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }];
+    };
+    quantized: {
+        formatVersion: 2;
+        modelTopology: Record<string, unknown>;
+        kind: "sequence-parser";
+        architecture: "embedding-window-mlp";
+        taskModule: string;
+        decoderModule: string;
+        taskMetadata: unknown;
+        readout: "all" | "last";
+        tokenizer: "characters" | "words";
+        vocabulary: string[];
+        labels: string[];
+        radius: number;
+        threshold: number;
+        precision: "float32" | "int8";
+        weights: [{
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }];
+    };
+    history: number[];
+    parity: {
+        examples: number;
+        maxConfidenceError: number;
+        labelDisagreements: number;
+    };
+    supervisedTokens: number;
+}>;
+//# sourceMappingURL=fit-sequence.d.ts.map

package/dist/models/sequence/fit-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit-sequence.d.ts","sourceRoot":"","sources":["../../../src/models/sequence/fit-sequence.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,SAAS,cAAc,CAAC,OAAO,CAAC,EAAE,EAC5C,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,GAAG,cAAc,GAAG,eAAe,CAAC,EACjF,MAAM,GAAE,SAAS,MAAM,EAAO,EAC9B,aAAa,UAAQ,EACrB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HjD"}

package/dist/models/sequence/index.d.ts

@@ -0,0 +1,3 @@
+export { runSequence } from "./run-sequence.js";
+export type { SequenceRecipe } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/models/sequence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/sequence/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/models/sequence/run-sequence.d.ts

@@ -0,0 +1,162 @@
+import type { loadProject } from "../../load-project.js";
+export declare function runSequence(command: "train" | "eval", project: Awaited<ReturnType<typeof loadProject>>, progress?: (epoch: number, loss: number) => void): Promise<{
+    evaluation: {
+        examples: number;
+        invalidOutputRate: number;
+        exactAccuracy: number;
+        accepted: number;
+        acceptedAccuracy: number | null;
+        abstentionRate: number;
+        correctAbstentions: number;
+        failures: {
+            input: string;
+            expected: unknown;
+            actual: unknown;
+        }[];
+    };
+    report?: never;
+    output?: never;
+} | {
+    evaluation?: never;
+    report: {
+        formatVersion: number;
+        architecture: "embedding-window-mlp";
+        backend: string;
+        seed: number;
+        artifactSha256: string;
+        bytes: number;
+        parameters: number;
+        datasetSha256: {
+            source: string;
+            sha256: string;
+        }[];
+        examples: {
+            train: number;
+            validation: number;
+            eval: number;
+        };
+        shuffledLabelsUngated: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        } | null;
+        supervisedTokens: number;
+        loss: number[];
+        exportParity: {
+            examples: number;
+            maxConfidenceError: number;
+            labelDisagreements: number;
+        };
+        validation: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        };
+        untrainedUngated: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        };
+        untrained: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        };
+        float: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        };
+        quantized: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        };
+        challenges: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        } | null;
+        baseline: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        } | null;
+        trainingMs: number;
+        notes: string;
+    };
+    output: string;
+}>;
+//# sourceMappingURL=run-sequence.d.ts.map

package/dist/models/sequence/run-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-sequence.d.ts","sourceRoot":"","sources":["../../../src/models/sequence/run-sequence.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAMzD,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,GAAG,MAAM,EACzB,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,EAChD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqF5C,KAAK;YACL,UAAU;YACV,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BT"}

package/dist/models/sequence/types.d.ts

@@ -0,0 +1,10 @@
+import type { DatasetExample } from "@matchbox-ai/core";
+import type { Token } from "@matchbox-ai/core/runtime";
+/** Experimental supervision adapter. Application-facing datasets remain input/output JSONL. */
+export interface SequenceRecipe {
+    tokenizer: "characters" | "words";
+    readout: "all" | "last";
+    labels: readonly string[];
+    annotate(example: DatasetExample<unknown>, tokens: readonly Token[]): readonly (string | null)[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/models/sequence/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/models/sequence/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,+FAA+F;AAC/F,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC;IAClC,OAAO,EAAE,KAAK,GAAG,MAAM,CAAC;IACxB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAClG"}

package/dist/package-model-CPj0qnQs.js

@@ -0,0 +1,18 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+//#region src/packaging/package-model.ts
+async function packageModel(output, model, report) {
+	await mkdir(dirname(output), { recursive: true });
+	const declaration = output.replace(/\.matchbox$/, ".d.matchbox.ts");
+	if (declaration === output) throw new Error("The output filename must end in .matchbox.");
+	const decoderImport = model.decoderModule === null ? "" : `import decode from ${JSON.stringify(model.decoderModule.replace(/\.ts$/, ""))};\n`;
+	const taskImport = model.taskModule.replace(/\.ts$/, "");
+	await writeFile(output, JSON.stringify(model));
+	await writeFile(declaration, `import task from ${JSON.stringify(taskImport)};\nimport type { InferOutput } from "@matchbox-ai/core";\nimport type { MatchboxParser } from "@matchbox-ai/core/runtime";\ndeclare const parser: MatchboxParser<InferOutput<typeof task>> & { load(): Promise<void>; dispose(): void };\nexport default parser;\n`);
+	await writeFile(resolve(dirname(output), "report.json"), JSON.stringify(report, null, 2) + "\n");
+	await writeFile(output.replace(/\.matchbox$/, ".ts"), `import task from ${JSON.stringify(taskImport)};\n${decoderImport}import { createParser } from "@matchbox-ai/core/runtime";\nconst model = ${JSON.stringify(model)};\nexport default createParser(model, task${model.decoderModule === null ? "" : ", decode"});\n`);
+}
+//#endregion
+export { packageModel as t };
+
+//# sourceMappingURL=package-model-CPj0qnQs.js.map

package/dist/package-model-CPj0qnQs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-model-CPj0qnQs.js","names":[],"sources":["../src/packaging/package-model.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { dirname, resolve } from \"node:path\";\nimport type { SequenceArtifact, RecordArtifact } from \"@matchbox-ai/core/internal\";\nexport async function packageModel(\n  output: string,\n  model: SequenceArtifact | RecordArtifact,\n  report: unknown,\n) {\n  await mkdir(dirname(output), { recursive: true });\n  const declaration = output.replace(/\\.matchbox$/, \".d.matchbox.ts\");\n  if (declaration === output) throw new Error(\"The output filename must end in .matchbox.\");\n  const decoderImport =\n    model.decoderModule === null\n      ? \"\"\n      : `import decode from ${JSON.stringify(model.decoderModule.replace(/\\.ts$/, \"\"))};\\n`;\n  const taskImport = model.taskModule.replace(/\\.ts$/, \"\");\n  await writeFile(output, JSON.stringify(model));\n  await writeFile(\n    declaration,\n    `import task from ${JSON.stringify(taskImport)};\\nimport type { InferOutput } from \"@matchbox-ai/core\";\\nimport type { MatchboxParser } from \"@matchbox-ai/core/runtime\";\\ndeclare const parser: MatchboxParser<InferOutput<typeof task>> & { load(): Promise<void>; dispose(): void };\\nexport default parser;\\n`,\n  );\n  await writeFile(resolve(dirname(output), \"report.json\"), JSON.stringify(report, null, 2) + \"\\n\");\n  // A portable wrapper for bundlers without the Vite plugin; inference still remains local.\n  await writeFile(\n    output.replace(/\\.matchbox$/, \".ts\"),\n    `import task from ${JSON.stringify(taskImport)};\\n${decoderImport}import { createParser } from \"@matchbox-ai/core/runtime\";\\nconst model = ${JSON.stringify(model)};\\nexport default createParser(model, task${model.decoderModule === null ? \"\" : \", decode\"});\\n`,\n  );\n}\n"],"mappings":";;;AAGA,eAAsB,aACpB,QACA,OACA,QACA;CACA,MAAM,MAAM,QAAQ,MAAM,GAAG,EAAE,WAAW,KAAK,CAAC;CAChD,MAAM,cAAc,OAAO,QAAQ,eAAe,gBAAgB;CAClE,IAAI,gBAAgB,QAAQ,MAAM,IAAI,MAAM,4CAA4C;CACxF,MAAM,gBACJ,MAAM,kBAAkB,OACpB,KACA,sBAAsB,KAAK,UAAU,MAAM,cAAc,QAAQ,SAAS,EAAE,CAAC,EAAE;CACrF,MAAM,aAAa,MAAM,WAAW,QAAQ,SAAS,EAAE;CACvD,MAAM,UAAU,QAAQ,KAAK,UAAU,KAAK,CAAC;CAC7C,MAAM,UACJ,aACA,oBAAoB,KAAK,UAAU,UAAU,EAAE,mQACjD;CACA,MAAM,UAAU,QAAQ,QAAQ,MAAM,GAAG,aAAa,GAAG,KAAK,UAAU,QAAQ,MAAM,CAAC,IAAI,IAAI;CAE/F,MAAM,UACJ,OAAO,QAAQ,eAAe,KAAK,GACnC,oBAAoB,KAAK,UAAU,UAAU,EAAE,KAAK,cAAc,2EAA2E,KAAK,UAAU,KAAK,EAAE,4CAA4C,MAAM,kBAAkB,OAAO,KAAK,WAAW,KAChQ;AACF"}

package/dist/packaging/package-model.d.ts

@@ -0,0 +1,3 @@
+import type { SequenceArtifact, RecordArtifact } from "@matchbox-ai/core/internal";
+export declare function packageModel(output: string, model: SequenceArtifact | RecordArtifact, report: unknown): Promise<void>;
+//# sourceMappingURL=package-model.d.ts.map

package/dist/packaging/package-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-model.d.ts","sourceRoot":"","sources":["../../src/packaging/package-model.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACnF,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,GAAG,cAAc,EACxC,MAAM,EAAE,OAAO,iBAqBhB"}

package/dist/pipeline/define-pipeline.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const pipelineSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"words">;
+    }, z.core.$strict>>;
+    prediction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"field-classifier">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"token-classifier">;
+        recipe: z.ZodString;
+        decode: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    acceptance: z.ZodOptional<z.ZodObject<{
+        minAccuracy: z.ZodOptional<z.ZodNumber>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Pipeline = z.infer<typeof pipelineSchema>;
+export declare function definePipeline(pipeline: Pipeline): Pipeline;
+//# sourceMappingURL=define-pipeline.d.ts.map

package/dist/pipeline/define-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-pipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline/define-pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kBA+BvB,CAAC;AACL,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAE3D"}

package/dist/pipeline/index.d.ts

@@ -0,0 +1,3 @@
+export { definePipeline, pipelineSchema } from "./define-pipeline.js";
+export type { Pipeline } from "./define-pipeline.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pipeline/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipeline/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtE,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/project/artifact.d.ts

@@ -0,0 +1,129 @@
+import type { SequenceDecoder } from "@matchbox-ai/core/runtime";
+import type { ParserDefinition } from "@matchbox-ai/core";
+import type { z } from "zod";
+export declare function loadArtifact(configPath: string): Promise<{
+    artifact: {
+        formatVersion: 2;
+        modelTopology: Record<string, unknown>;
+        kind: "sequence-parser";
+        architecture: "embedding-window-mlp";
+        taskModule: string;
+        decoderModule: string;
+        taskMetadata: unknown;
+        readout: "all" | "last";
+        tokenizer: "characters" | "words";
+        vocabulary: string[];
+        labels: string[];
+        radius: number;
+        threshold: number;
+        precision: "float32" | "int8";
+        weights: [{
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }];
+    } | {
+        formatVersion: 2;
+        modelTopology: Record<string, unknown>;
+        kind: "record-parser";
+        architecture: "bag-of-words-mlp";
+        taskModule: string;
+        decoderModule: null;
+        taskMetadata: unknown;
+        vocabulary: string[];
+        fields: {
+            name: string;
+            values: (string | number | boolean | null)[];
+        }[];
+        threshold: number;
+        precision: "float32" | "int8";
+        weights: [{
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }, {
+            name: string;
+            shape: number[];
+            values: number[];
+            scale: number;
+        }];
+    };
+    task: ParserDefinition<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    decode: SequenceDecoder | undefined;
+    parser: import("@matchbox-ai/core/runtime").MatchboxParser<unknown> & {
+        load(): Promise<void>;
+        dispose(): void;
+    };
+    inspect: (input: string) => Promise<{
+        fields: {
+            field: string;
+            value: string | number | boolean | null | undefined;
+            confidence: number;
+        }[];
+        value: {
+            [k: string]: string | number | boolean | null | undefined;
+        };
+        confidence: number;
+    } | {
+        tokens: {
+            text: string;
+            key: string;
+            start: number;
+            end: number;
+            label: string;
+            confidence: number;
+        }[];
+        candidate: unknown;
+    }>;
+    output: string;
+    config: {
+        formatVersion: 1;
+        task: string;
+        train: string;
+        validation: string;
+        eval: string;
+        output: string;
+        minAccuracy: number;
+        maxBytes: number;
+        sequence?: {
+            recipe: string;
+            decoder: string;
+        } | undefined;
+        baseline?: string | undefined;
+        challenges?: string | undefined;
+    };
+    root: string;
+}>;
+//# sourceMappingURL=artifact.d.ts.map

package/dist/project/artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact.d.ts","sourceRoot":"","sources":["../../src/project/artifact.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoB1B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAchC"}

package/dist/project/config.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const configSchema: z.ZodObject<{
+    formatVersion: z.ZodDefault<z.ZodLiteral<1>>;
+    task: z.ZodDefault<z.ZodString>;
+    train: z.ZodDefault<z.ZodString>;
+    validation: z.ZodDefault<z.ZodString>;
+    eval: z.ZodDefault<z.ZodString>;
+    output: z.ZodString;
+    minAccuracy: z.ZodDefault<z.ZodNumber>;
+    maxBytes: z.ZodDefault<z.ZodNumber>;
+    sequence: z.ZodOptional<z.ZodObject<{
+        recipe: z.ZodString;
+        decoder: z.ZodString;
+    }, z.core.$strict>>;
+    baseline: z.ZodOptional<z.ZodString>;
+    challenges: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare function loadConfig(path: string): Promise<{
+    config: {
+        formatVersion: 1;
+        task: string;
+        train: string;
+        validation: string;
+        eval: string;
+        output: string;
+        minAccuracy: number;
+        maxBytes: number;
+        sequence?: {
+            recipe: string;
+            decoder: string;
+        } | undefined;
+        baseline?: string | undefined;
+        challenges?: string | undefined;
+    };
+    root: string;
+}>;
+//# sourceMappingURL=config.d.ts.map

package/dist/project/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/project/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;kBAYvB,CAAC;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;;GAsC5C"}

package/dist/project/discover.d.ts

@@ -0,0 +1,2 @@
+export declare function discover(target?: string, cwd?: string): Promise<string>;
+//# sourceMappingURL=discover.d.ts.map

package/dist/project/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/project/discover.ts"],"names":[],"mappings":"AAuBA,wBAAsB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BpF"}

package/dist/project/index.d.ts

@@ -0,0 +1,4 @@
+export { loadConfig } from "./config.js";
+export { discover } from "./discover.js";
+export { loadArtifact } from "./artifact.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/project/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/project/index.js

@@ -0,0 +1,2 @@
+import { n as discover, r as loadConfig, t as loadArtifact } from "../project-BP331m20.js";
+export { discover, loadArtifact, loadConfig };