@matchbox-ai/train 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @matchbox-ai/train
+
+## 0.1.0
+
+### Minor Changes
+
+- b1374ca: Release the first examples-to-browser toolchain, including typed local inference, explicit TensorFlow training pipelines, and the matchbox-ai CLI with task scaffolding and a browser workbench.
+
+### Patch Changes
+
+- Updated dependencies [b1374ca]
+  - @matchbox-ai/core@0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Boolean Industries Sweden AB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @matchbox-ai/train
+
+Read [the bundled documentation](docs/README.md) for the installed version. Train exports explicit pipeline primitives and programmatic training. Install matchbox-ai for the matchbox-ai command and browser workbench. Native TensorFlow loads for training; these modules must not enter browser bundles.

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,17 @@
+# Third-party components
+
+## Fluid Functionalism
+
+The button in `apps/playground/src/components/ui/button/` is adapted from [Fluid Functionalism](https://www.fluidfunctionalism.com/docs/button), created by [@micka_design](https://x.com/micka_design).
+
+Source: <https://www.fluidfunctionalism.com/r/button.json>. Retrieved on 2026-09-13.
+
+The adaptation preserves the registry's layered background, press effect, four surface variants, focus ring, and rounded default. It removes unused icon, loading, Slot, legacy-size, and provider APIs for this minimal example. It adds reduced-motion handling and splits styling from the React component to follow repository conventions.
+
+Only dependencies used by the adapted component are installed. The wider registry's animation and icon dependencies are not required for this button subset.
+
+The Inter variable font is supplied by `@fontsource-variable/inter`; its license is distributed with that dependency.
+
+## Country reference data
+
+The country names and English demonyms in `examples/filters/matchbox/filters/lib/countries/countries.json` are derived from [mledoze/countries](https://github.com/mledoze/countries), retrieved 2026-09-13. The derived database is provided under ODbL 1.0; the license is included alongside the data. Shared demonyms prefer a unique independent country; unresolved ambiguous aliases and empty aliases are omitted.

package/dist/codecs/index.d.ts

@@ -0,0 +1,2 @@
+export type { SequenceDecoder as OutputDecoder } from "@matchbox-ai/core/runtime";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codecs/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,eAAe,IAAI,aAAa,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/define-pipeline-Colvwt7u.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+//#region src/pipeline/define-pipeline.ts
+const pipelineSchema = z.strictObject({
+	input: z.strictObject({ kind: z.literal("words") }).optional(),
+	prediction: z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("field-classifier") }), z.strictObject({
+		kind: z.literal("token-classifier"),
+		recipe: z.string().min(1),
+		decode: z.string().min(1)
+	})]),
+	acceptance: z.strictObject({
+		minAccuracy: z.number().min(0).max(1).optional(),
+		maxBytes: z.number().positive().optional()
+	}).optional()
+}).superRefine((value, context) => {
+	if (value.prediction.kind === "field-classifier" && !value.input) context.addIssue({
+		code: "custom",
+		message: "fieldClassifier requires an explicit input encoder.",
+		path: ["input"]
+	});
+	if (value.prediction.kind === "token-classifier" && value.input) context.addIssue({
+		code: "custom",
+		message: "The sequence recipe owns tokenization; omit the duplicate input encoder.",
+		path: ["input"]
+	});
+});
+function definePipeline(pipeline) {
+	return pipelineSchema.parse(pipeline);
+}
+//#endregion
+export { pipelineSchema as n, definePipeline as t };
+
+//# sourceMappingURL=define-pipeline-Colvwt7u.js.map

package/dist/define-pipeline-Colvwt7u.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-pipeline-Colvwt7u.js","names":[],"sources":["../src/pipeline/define-pipeline.ts"],"sourcesContent":["import { z } from \"zod\";\nexport const pipelineSchema = z\n  .strictObject({\n    input: z.strictObject({ kind: z.literal(\"words\") }).optional(),\n    prediction: z.discriminatedUnion(\"kind\", [\n      z.strictObject({ kind: z.literal(\"field-classifier\") }),\n      z.strictObject({\n        kind: z.literal(\"token-classifier\"),\n        recipe: z.string().min(1),\n        decode: z.string().min(1),\n      }),\n    ]),\n    acceptance: z\n      .strictObject({\n        minAccuracy: z.number().min(0).max(1).optional(),\n        maxBytes: z.number().positive().optional(),\n      })\n      .optional(),\n  })\n  .superRefine((value, context) => {\n    if (value.prediction.kind === \"field-classifier\" && !value.input)\n      context.addIssue({\n        code: \"custom\",\n        message: \"fieldClassifier requires an explicit input encoder.\",\n        path: [\"input\"],\n      });\n    if (value.prediction.kind === \"token-classifier\" && value.input)\n      context.addIssue({\n        code: \"custom\",\n        message: \"The sequence recipe owns tokenization; omit the duplicate input encoder.\",\n        path: [\"input\"],\n      });\n  });\nexport type Pipeline = z.infer<typeof pipelineSchema>;\nexport function definePipeline(pipeline: Pipeline): Pipeline {\n  return pipelineSchema.parse(pipeline);\n}\n"],"mappings":";;AACA,MAAa,iBAAiB,EAC3B,aAAa;CACZ,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS;CAC7D,YAAY,EAAE,mBAAmB,QAAQ,CACvC,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,kBAAkB,EAAE,CAAC,GACtD,EAAE,aAAa;EACb,MAAM,EAAE,QAAQ,kBAAkB;EAClC,QAAQ,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;EACxB,QAAQ,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAC1B,CAAC,CACH,CAAC;CACD,YAAY,EACT,aAAa;EACZ,aAAa,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;EAC/C,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CAC3C,CAAC,CAAC,CACD,SAAS;AACd,CAAC,CAAC,CACD,aAAa,OAAO,YAAY;CAC/B,IAAI,MAAM,WAAW,SAAS,sBAAsB,CAAC,MAAM,OACzD,QAAQ,SAAS;EACf,MAAM;EACN,SAAS;EACT,MAAM,CAAC,OAAO;CAChB,CAAC;CACH,IAAI,MAAM,WAAW,SAAS,sBAAsB,MAAM,OACxD,QAAQ,SAAS;EACf,MAAM;EACN,SAAS;EACT,MAAM,CAAC,OAAO;CAChB,CAAC;AACL,CAAC;AAEH,SAAgB,eAAe,UAA8B;CAC3D,OAAO,eAAe,MAAM,QAAQ;AACtC"}

package/dist/encoders/index.d.ts

@@ -0,0 +1,3 @@
+export { wordTokens } from "./word-tokens.js";
+export { tokenize } from "@matchbox-ai/core/internal";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/encoders/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/encoders/word-tokens.d.ts

@@ -0,0 +1,5 @@
+/** Literal word tokens. Unseen vocabulary causes abstention. */
+export declare function wordTokens(): {
+    readonly kind: "words";
+};
+//# sourceMappingURL=word-tokens.d.ts.map

package/dist/encoders/word-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-tokens.d.ts","sourceRoot":"","sources":["../../src/encoders/word-tokens.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,wBAAgB,UAAU;aACf,IAAI,EAAE,OAAO;EACvB"}

package/dist/evaluate-sequence-ZCwyomzQ.js

@@ -0,0 +1,42 @@
+//#region src/evaluation/same-output.ts
+function sameOutput(left, right) {
+	const canonical = (value) => JSON.stringify(value, (_key, item) => item !== null && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item);
+	return canonical(left) === canonical(right);
+}
+//#endregion
+//#region src/evaluation/evaluate-sequence.ts
+async function evaluateSequence(parser, examples, validate) {
+	let exact = 0, accepted = 0, correctAccepted = 0, correctAbstentions = 0;
+	let invalidOutputs = 0;
+	const failures = [];
+	for (const row of examples) {
+		const result = await parser.parse(row.input);
+		const actual = result.status === "ok" ? result.value : null;
+		if (result.status === "ok" && !validate(result.value)) invalidOutputs++;
+		const correct = sameOutput(actual, row.output);
+		if (correct) exact++;
+		if (result.status === "ok") {
+			accepted++;
+			if (correct) correctAccepted++;
+		} else if (row.output === null) correctAbstentions++;
+		if (!correct) failures.push({
+			input: row.input,
+			expected: row.output,
+			actual
+		});
+	}
+	return {
+		examples: examples.length,
+		invalidOutputRate: invalidOutputs / examples.length,
+		exactAccuracy: exact / examples.length,
+		accepted,
+		acceptedAccuracy: accepted ? correctAccepted / accepted : null,
+		abstentionRate: 1 - accepted / examples.length,
+		correctAbstentions,
+		failures
+	};
+}
+//#endregion
+export { sameOutput as n, evaluateSequence as t };
+
+//# sourceMappingURL=evaluate-sequence-ZCwyomzQ.js.map

package/dist/evaluate-sequence-ZCwyomzQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-sequence-ZCwyomzQ.js","names":[],"sources":["../src/evaluation/same-output.ts","../src/evaluation/evaluate-sequence.ts"],"sourcesContent":["export function sameOutput(left: unknown, right: unknown): boolean {\n  const canonical = (value: unknown) =>\n    JSON.stringify(value, (_key, item: unknown) =>\n      item !== null && typeof item === \"object\" && !Array.isArray(item)\n        ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)))\n        : item,\n    );\n  return canonical(left) === canonical(right);\n}\n","import { sameOutput } from \"./same-output.js\";\nimport type { DatasetExample } from \"@matchbox-ai/core\";\nimport type { MatchboxParser } from \"@matchbox-ai/core/runtime\";\nexport async function evaluateSequence(\n  parser: MatchboxParser<unknown>,\n  examples: readonly DatasetExample<unknown>[],\n  validate: (value: unknown) => boolean,\n) {\n  let exact = 0,\n    accepted = 0,\n    correctAccepted = 0,\n    correctAbstentions = 0;\n  let invalidOutputs = 0;\n  const failures: { input: string; expected: unknown; actual: unknown }[] = [];\n  for (const row of examples) {\n    const result = await parser.parse(row.input);\n    const actual = result.status === \"ok\" ? result.value : null;\n    if (result.status === \"ok\" && !validate(result.value)) invalidOutputs++;\n    const correct = sameOutput(actual, row.output);\n    if (correct) exact++;\n    if (result.status === \"ok\") {\n      accepted++;\n      if (correct) correctAccepted++;\n    } else if (row.output === null) correctAbstentions++;\n    if (!correct) failures.push({ input: row.input, expected: row.output, actual });\n  }\n  return {\n    examples: examples.length,\n    invalidOutputRate: invalidOutputs / examples.length,\n    exactAccuracy: exact / examples.length,\n    accepted,\n    acceptedAccuracy: accepted ? correctAccepted / accepted : null,\n    abstentionRate: 1 - accepted / examples.length,\n    correctAbstentions,\n    failures,\n  };\n}\n"],"mappings":";AAAA,SAAgB,WAAW,MAAe,OAAyB;CACjE,MAAM,aAAa,UACjB,KAAK,UAAU,QAAQ,MAAM,SAC3B,SAAS,QAAQ,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,IAC5D,OAAO,YAAY,OAAO,QAAQ,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,IAC9E,IACN;CACF,OAAO,UAAU,IAAI,MAAM,UAAU,KAAK;AAC5C;;;ACLA,eAAsB,iBACpB,QACA,UACA,UACA;CACA,IAAI,QAAQ,GACV,WAAW,GACX,kBAAkB,GAClB,qBAAqB;CACvB,IAAI,iBAAiB;CACrB,MAAM,WAAoE,CAAC;CAC3E,KAAK,MAAM,OAAO,UAAU;EAC1B,MAAM,SAAS,MAAM,OAAO,MAAM,IAAI,KAAK;EAC3C,MAAM,SAAS,OAAO,WAAW,OAAO,OAAO,QAAQ;EACvD,IAAI,OAAO,WAAW,QAAQ,CAAC,SAAS,OAAO,KAAK,GAAG;EACvD,MAAM,UAAU,WAAW,QAAQ,IAAI,MAAM;EAC7C,IAAI,SAAS;EACb,IAAI,OAAO,WAAW,MAAM;GAC1B;GACA,IAAI,SAAS;EACf,OAAO,IAAI,IAAI,WAAW,MAAM;EAChC,IAAI,CAAC,SAAS,SAAS,KAAK;GAAE,OAAO,IAAI;GAAO,UAAU,IAAI;GAAQ;EAAO,CAAC;CAChF;CACA,OAAO;EACL,UAAU,SAAS;EACnB,mBAAmB,iBAAiB,SAAS;EAC7C,eAAe,QAAQ,SAAS;EAChC;EACA,kBAAkB,WAAW,kBAAkB,WAAW;EAC1D,gBAAgB,IAAI,WAAW,SAAS;EACxC;EACA;CACF;AACF"}

package/dist/evaluation/evaluate-sequence.d.ts

@@ -0,0 +1,17 @@
+import type { DatasetExample } from "@matchbox-ai/core";
+import type { MatchboxParser } from "@matchbox-ai/core/runtime";
+export declare function evaluateSequence(parser: MatchboxParser<unknown>, examples: readonly DatasetExample<unknown>[], validate: (value: unknown) => boolean): Promise<{
+    examples: number;
+    invalidOutputRate: number;
+    exactAccuracy: number;
+    accepted: number;
+    acceptedAccuracy: number | null;
+    abstentionRate: number;
+    correctAbstentions: number;
+    failures: {
+        input: string;
+        expected: unknown;
+        actual: unknown;
+    }[];
+}>;
+//# sourceMappingURL=evaluate-sequence.d.ts.map

package/dist/evaluation/evaluate-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-sequence.d.ts","sourceRoot":"","sources":["../../src/evaluation/evaluate-sequence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,cAAc,CAAC,OAAO,CAAC,EAC/B,QAAQ,EAAE,SAAS,cAAc,CAAC,OAAO,CAAC,EAAE,EAC5C,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO;;;;;;;;;eAOZ,MAAM;kBAAY,OAAO;gBAAU,OAAO;;GAuBpE"}

package/dist/evaluation/same-output.d.ts

@@ -0,0 +1,2 @@
+export declare function sameOutput(left: unknown, right: unknown): boolean;
+//# sourceMappingURL=same-output.d.ts.map

package/dist/evaluation/same-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"same-output.d.ts","sourceRoot":"","sources":["../../src/evaluation/same-output.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAQjE"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { definePipeline } from "./pipeline/index.js";
+export type { Pipeline } from "./pipeline/index.js";
+export { wordTokens, tokenize } from "./encoders/index.js";
+export { fieldClassifier, tokenClassifier } from "./models/index.js";
+export type { OutputDecoder } from "./codecs/index.js";
+export { train } from "./train.js";
+export { evaluateSequence as evaluate } from "./evaluation/evaluate-sequence.js";
+export type { TrainingConfig } from "./types.js";
+export type { SequenceRecipe } from "./models/sequence/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,gBAAgB,IAAI,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AACjF,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,33 @@
+import { t as definePipeline } from "./define-pipeline-Colvwt7u.js";
+import { t as evaluateSequence } from "./evaluate-sequence-ZCwyomzQ.js";
+import { tokenize } from "@matchbox-ai/core/internal";
+//#region src/encoders/word-tokens.ts
+/** Literal word tokens. Unseen vocabulary causes abstention. */
+function wordTokens() {
+	return { kind: "words" };
+}
+//#endregion
+//#region src/models/presets.ts
+/** Independent field classification over training values. Numeric outputs are finite classes. */
+function fieldClassifier() {
+	return { kind: "field-classifier" };
+}
+/** Application-owned span supervision and deterministic decoding. Paths are relative to pipeline.ts. */
+function tokenClassifier(options) {
+	return {
+		kind: "token-classifier",
+		...options
+	};
+}
+//#endregion
+//#region src/train.ts
+/** Runs the same validation, selection, and packaging pipeline as the CLI. */
+async function train(target, options = {}) {
+	const { discover } = await import("./project/index.js");
+	const { run } = await import("./run-Cwa7vD_T.js");
+	return run("train", await discover(target), options.onProgress);
+}
+//#endregion
+export { definePipeline, evaluateSequence as evaluate, fieldClassifier, tokenClassifier, tokenize, train, wordTokens };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/encoders/word-tokens.ts","../src/models/presets.ts","../src/train.ts"],"sourcesContent":["/** Literal word tokens. Unseen vocabulary causes abstention. */\nexport function wordTokens() {\n  return { kind: \"words\" } as const;\n}\n","/** Independent field classification over training values. Numeric outputs are finite classes. */\nexport function fieldClassifier() {\n  return { kind: \"field-classifier\" } as const;\n}\n/** Application-owned span supervision and deterministic decoding. Paths are relative to pipeline.ts. */\nexport function tokenClassifier(options: { recipe: string; decode: string }) {\n  return { kind: \"token-classifier\", ...options } as const;\n}\n","/** Runs the same validation, selection, and packaging pipeline as the CLI. */\nexport async function train(\n  target: string,\n  options: { onProgress?: (epoch: number, loss: number) => void } = {},\n) {\n  const { discover } = await import(\"./project/index.js\");\n  const { run } = await import(\"./run.js\");\n  return run(\"train\", await discover(target), options.onProgress);\n}\n"],"mappings":";;;;;AACA,SAAgB,aAAa;CAC3B,OAAO,EAAE,MAAM,QAAQ;AACzB;;;;ACFA,SAAgB,kBAAkB;CAChC,OAAO,EAAE,MAAM,mBAAmB;AACpC;;AAEA,SAAgB,gBAAgB,SAA6C;CAC3E,OAAO;EAAE,MAAM;EAAoB,GAAG;CAAQ;AAChD;;;;ACNA,eAAsB,MACpB,QACA,UAAkE,CAAC,GACnE;CACA,MAAM,EAAE,aAAa,MAAM,OAAO;CAClC,MAAM,EAAE,QAAQ,MAAM,OAAO;CAC7B,OAAO,IAAI,SAAS,MAAM,SAAS,MAAM,GAAG,QAAQ,UAAU;AAChE"}

package/dist/load-project.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { ParserDefinition } from "@matchbox-ai/core";
+import type { MatchboxParser } from "@matchbox-ai/core/runtime";
+export declare function loadProject(path: string): Promise<{
+    root: 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;
+    };
+    task: ParserDefinition<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    baseline: MatchboxParser<unknown> | null;
+    taskPath: string;
+    output: string;
+    sources: {
+        source: string;
+        text: string;
+    }[];
+    train: readonly import("@matchbox-ai/core").DatasetExample<unknown>[];
+    validation: readonly import("@matchbox-ai/core").DatasetExample<unknown>[];
+    evaluation: readonly import("@matchbox-ai/core").DatasetExample<unknown>[];
+}>;
+//# sourceMappingURL=load-project.d.ts.map

package/dist/load-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-project.d.ts","sourceRoot":"","sources":["../src/load-project.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiD7C"}

package/dist/models/index.d.ts

@@ -0,0 +1,2 @@
+export { fieldClassifier, tokenClassifier } from "./presets.js";
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/models/presets.d.ts

@@ -0,0 +1,14 @@
+/** Independent field classification over training values. Numeric outputs are finite classes. */
+export declare function fieldClassifier(): {
+    readonly kind: "field-classifier";
+};
+/** Application-owned span supervision and deterministic decoding. Paths are relative to pipeline.ts. */
+export declare function tokenClassifier(options: {
+    recipe: string;
+    decode: string;
+}): {
+    readonly recipe: string;
+    readonly decode: string;
+    readonly kind: "token-classifier";
+};
+//# sourceMappingURL=presets.d.ts.map

package/dist/models/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/models/presets.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,wBAAgB,eAAe;aACpB,IAAI,EAAE,kBAAkB;EAClC;AACD,wGAAwG;AACxG,wBAAgB,eAAe,CAAC,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;qBAAxB,MAAM;qBAAU,MAAM;mBACxD,kBAAkB;EAClC"}

package/dist/models/record/fit.d.ts

@@ -0,0 +1,124 @@
+import type { DatasetExample, ParserMetadata } from "@matchbox-ai/core";
+export declare function fitRecord(examples: readonly DatasetExample<unknown>[], metadata: {
+    taskModule: string;
+    taskMetadata: ParserMetadata;
+}, probes: readonly string[], progress?: (epoch: number, loss: number) => void): Promise<{
+    float: {
+        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;
+        }];
+    };
+    quantized: {
+        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;
+        }];
+    };
+    untrained: {
+        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;
+        }];
+    };
+    history: number[];
+    parity: {
+        examples: number;
+        labelDisagreements: number;
+        maxConfidenceError: number;
+    };
+}>;
+//# sourceMappingURL=fit.d.ts.map

package/dist/models/record/fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit.d.ts","sourceRoot":"","sources":["../../../src/models/record/fit.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxE,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,SAAS,cAAc,CAAC,OAAO,CAAC,EAAE,EAC5C,QAAQ,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,cAAc,CAAA;CAAE,EAC9D,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqIjD"}

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

@@ -0,0 +1,2 @@
+export { runRecord } from "./run.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/record/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC"}

package/dist/models/record/run.d.ts

@@ -0,0 +1,115 @@
+import type { loadProject } from "../../load-project.js";
+export declare function runRecord(project: Awaited<ReturnType<typeof loadProject>>, progress?: (epoch: number, loss: number) => void): Promise<{
+    report: {
+        formatVersion: number;
+        architecture: "bag-of-words-mlp";
+        backend: string;
+        seed: number;
+        artifactSha256: string;
+        bytes: number;
+        parameters: number;
+        datasetSha256: {
+            source: string;
+            sha256: string;
+        }[];
+        examples: {
+            train: number;
+            validation: number;
+            eval: number;
+        };
+        loss: number[];
+        exportParity: {
+            examples: number;
+            labelDisagreements: number;
+            maxConfidenceError: number;
+        };
+        validation: {
+            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;
+            }[];
+        };
+        float: {
+            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;
+            }[];
+        };
+        untrainedUngated: {
+            examples: number;
+            invalidOutputRate: number;
+            exactAccuracy: number;
+            accepted: number;
+            acceptedAccuracy: number | null;
+            abstentionRate: number;
+            correctAbstentions: number;
+            failures: {
+                input: string;
+                expected: unknown;
+                actual: unknown;
+            }[];
+        };
+        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.d.ts.map

package/dist/models/record/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/models/record/run.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIzD,wBAAsB,SAAS,CAC7B,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,EAChD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;YA4C5C,KAAK;YACL,UAAU;YACV,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBT"}

package/dist/models/record/verify-export.d.ts

@@ -0,0 +1,8 @@
+import * as tf from "@tensorflow/tfjs-node";
+import type { RecordArtifact } from "@matchbox-ai/core/internal";
+export declare function verifyExport(model: tf.LayersModel, artifact: RecordArtifact, probes: readonly string[]): Promise<{
+    examples: number;
+    labelDisagreements: number;
+    maxConfidenceError: number;
+}>;
+//# sourceMappingURL=verify-export.d.ts.map

package/dist/models/record/verify-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-export.d.ts","sourceRoot":"","sources":["../../../src/models/record/verify-export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,wBAAsB,YAAY,CAChC,KAAK,EAAE,EAAE,CAAC,WAAW,EACrB,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,SAAS,MAAM,EAAE;;;;GAyC1B"}

package/dist/models/sequence/create-network.d.ts

@@ -0,0 +1,3 @@
+import * as tf from "@tensorflow/tfjs-node";
+export declare function createNetwork(vocabularySize: number, labelCount: number): tf.Sequential;
+//# sourceMappingURL=create-network.d.ts.map

package/dist/models/sequence/create-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-network.d.ts","sourceRoot":"","sources":["../../../src/models/sequence/create-network.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC5C,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,iBA0BvE"}