@matchbox-ai/train 0.1.0 → 0.2.1

package/dist/sequence-DGoGU7kG.js

@@ -0,0 +1,219 @@
+import { n as sameOutput, t as evaluateSequence } from "./evaluate-sequence-ZCwyomzQ.js";
+import { t as packageModel } from "./package-model-CPj0qnQs.js";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { readSequenceArtifact, tensorPredictor, tokenize, windows } from "@matchbox-ai/core/internal";
+import { readFile } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createParser } from "@matchbox-ai/core/runtime";
+import { createHash } from "node:crypto";
+//#region src/native/fit.ts
+const require = createRequire(import.meta.url);
+function predict(config, weights, inputs) {
+	return require("#native").predict(JSON.stringify(config), Buffer.from(weights), Int32Array.from(inputs.flat()));
+}
+function fit(config, inputs, labels, progress) {
+	return require("#native").fit(JSON.stringify(config), Int32Array.from(inputs.flat()), Int32Array.from(labels), (error, value) => {
+		if (!error) progress?.(value[0], value[1]);
+	});
+}
+//#endregion
+//#region src/models/sequence/prepare-supervision.ts
+function prepareSupervision(examples, recipe) {
+	const vocabulary = [...new Set(examples.flatMap((row) => tokenize(row.input, recipe.tokenizer).map((token) => token.key)))].sort();
+	const radius = 1;
+	const dropout = recipe.tokenDropout ?? 0;
+	if (!Number.isFinite(dropout) || dropout < 0 || dropout > .5) throw new Error("tokenDropout must be between 0 and 0.5.");
+	let maskingSeed = 7043;
+	const random = () => {
+		maskingSeed = Math.imul(maskingSeed, 1664525) + 1013904223 >>> 0;
+		return maskingSeed / 4294967296;
+	};
+	const inputs = [];
+	const labels = [];
+	for (const example of examples) {
+		const tokens = tokenize(example.input, recipe.tokenizer);
+		const annotations = recipe.annotate(example, tokens);
+		if (annotations.length !== tokens.length) throw new Error(`Annotation length mismatch: ${example.input}`);
+		windows(tokens, vocabulary, radius).forEach((window, position) => {
+			const label = annotations[position];
+			if (label === null) return;
+			const id = recipe.labels.indexOf(label);
+			if (id < 0) throw new Error(`Unknown annotation ${label}: ${example.input}`);
+			inputs.push(window);
+			labels.push(id);
+			if (dropout > 0) {
+				inputs.push(window.map((id) => id > 1 && random() < dropout ? 1 : id));
+				labels.push(id);
+			}
+		});
+	}
+	if (recipe.labels.some((_, id) => !labels.includes(id))) throw new Error("Every label needs supervised training examples.");
+	maskingSeed = 9187;
+	for (let index = inputs.length - 1; index > 0; index--) {
+		const other = Math.floor(random() * (index + 1));
+		[inputs[index], inputs[other]] = [inputs[other], inputs[index]];
+		[labels[index], labels[other]] = [labels[other], labels[index]];
+	}
+	return {
+		vocabulary,
+		radius,
+		dropout,
+		inputs,
+		labels
+	};
+}
+//#endregion
+//#region src/models/sequence/fit-sequence.ts
+async function fitSequence(examples, recipe, metadata, probes = [], progress) {
+	const { vocabulary, radius, dropout, inputs, labels } = prepareSupervision(examples, recipe);
+	const result = await fit({
+		vocabularySize: vocabulary.length + 2,
+		labelCount: recipe.labels.length
+	}, inputs, labels, progress);
+	const artifact = (weights) => ({
+		formatVersion: 3,
+		engine: "burn-0.21",
+		kind: "sequence-parser",
+		architecture: "embedding-window-mlp",
+		...metadata,
+		tokenizer: recipe.tokenizer,
+		readout: recipe.readout,
+		vocabulary,
+		labels: [...recipe.labels],
+		radius,
+		unknownTokens: dropout > 0 ? "predict" : "abstain",
+		threshold: .75,
+		precision: "float32",
+		weights: Buffer.from(weights).toString("base64")
+	});
+	const model = artifact(result.weights);
+	const checked = [...examples.slice(0, 16).map((row) => row.input), ...probes];
+	const portable = await tensorPredictor(model);
+	let maxConfidenceError = 0;
+	let labelDisagreements = 0;
+	try {
+		for (const input of checked) {
+			const tokens = tokenize(input, recipe.tokenizer);
+			if (!tokens.length) continue;
+			const scores = predict({
+				vocabularySize: vocabulary.length + 2,
+				labelCount: recipe.labels.length
+			}, result.weights, windows(tokens, vocabulary, radius));
+			portable.sequence(input).forEach((token, index) => {
+				const row = scores.slice(index * recipe.labels.length, (index + 1) * recipe.labels.length);
+				const confidence = Math.max(...row);
+				maxConfidenceError = Math.max(maxConfidenceError, Math.abs(confidence - token.confidence));
+				if (recipe.labels[row.indexOf(confidence)] !== token.label) labelDisagreements++;
+			});
+		}
+	} finally {
+		portable.dispose();
+	}
+	if (labelDisagreements || maxConfidenceError > 1e-5) throw new Error("Burn native and WASM predictions disagree.");
+	return {
+		model,
+		parameters: result.parameters,
+		history: result.loss,
+		parity: {
+			examples: checked.length,
+			maxConfidenceError,
+			labelDisagreements
+		},
+		supervisedTokens: inputs.length
+	};
+}
+//#endregion
+//#region src/models/sequence/run-sequence.ts
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+async function runSequence(command, project, progress) {
+	const { task, config } = project;
+	const root = project.root;
+	const sequence = config.sequence;
+	if (!sequence) throw new Error("A sequence pipeline needs both recipe and decoder modules.");
+	const savedArtifact = command === "eval" ? readSequenceArtifact(JSON.parse(await readFile(project.output, "utf8"))) : null;
+	const decoderPath = savedArtifact ? resolve(dirname(project.output), savedArtifact.decoderModule) : resolve(root, sequence.decoder);
+	const decode = (await import(pathToFileURL(decoderPath).href)).default;
+	const evaluateSequence$1 = (parser, examples) => evaluateSequence(parser, examples, (value) => task.validateOutput(value).success).finally(() => {
+		if ("dispose" in parser && typeof parser.dispose === "function") parser.dispose();
+	});
+	const parser = (artifact) => createParser(artifact, task, decode);
+	if (savedArtifact) return { evaluation: await evaluateSequence$1(parser(savedArtifact), project.evaluation) };
+	const recipe = (await import(pathToFileURL(resolve(root, sequence.recipe)).href)).default;
+	const modulePath = (path) => {
+		const value = relative(dirname(project.output), path).replaceAll("\\", "/");
+		return value.startsWith(".") ? value : `./${value}`;
+	};
+	const rejections = z.array(z.strictObject({
+		input: z.string(),
+		output: z.null()
+	})).parse(recipe.rejections ?? []);
+	const training = [...project.train, ...rejections];
+	const heldOut = new Set([...project.validation, ...project.evaluation].map((row) => row.input.trim().toLowerCase()));
+	for (const example of training) {
+		if (!task.validateInput(example.input).success) throw new Error(`Invalid training input: ${example.input}`);
+		if (heldOut.has(example.input.trim().toLowerCase())) throw new Error(`Training input overlaps evaluation: ${example.input}`);
+		const tokens = tokenize(example.input, recipe.tokenizer);
+		const labels = recipe.annotate(example, tokens);
+		const value = decode(tokens.map((token, index) => ({
+			...token,
+			label: labels[index] ?? "O",
+			confidence: 1
+		})), example.input);
+		if (!sameOutput(value, example.output)) throw new Error(`Training annotations do not decode to the supplied output: ${example.input}`);
+	}
+	const started = performance.now();
+	const fit = await fitSequence(training, recipe, {
+		taskMetadata: task.toJSON(),
+		taskModule: modulePath(project.taskPath),
+		decoderModule: modulePath(resolve(root, sequence.decoder))
+	}, project.validation.map((row) => row.input), progress);
+	const validation = await evaluateSequence$1(parser(fit.model), project.validation);
+	const bytes = Buffer.byteLength(JSON.stringify(fit.model));
+	if (validation.exactAccuracy < config.minAccuracy || bytes > config.maxBytes) throw new Error(`Sequence model failed validation/size requirements (${validation.exactAccuracy}, ${bytes} bytes). ${JSON.stringify(validation.failures.slice(0, 10))}`);
+	const challenges = config.challenges ? z.array(z.strictObject({
+		input: z.string(),
+		output: z.null()
+	})).min(1).parse(JSON.parse(await readFile(resolve(root, config.challenges), "utf8"))) : null;
+	const report = {
+		formatVersion: 2,
+		architecture: fit.model.architecture,
+		backend: "Burn native CPU",
+		seed: 42,
+		artifactSha256: hash(JSON.stringify(fit.model)),
+		bytes,
+		parameters: fit.parameters,
+		datasetSha256: project.sources.map((source) => ({
+			source: source.source,
+			sha256: hash(source.text)
+		})),
+		examples: {
+			train: project.train.length,
+			rejections: recipe.rejections?.length ?? 0,
+			validation: project.validation.length,
+			eval: project.evaluation.length
+		},
+		supervisionSha256: hash(JSON.stringify(training.map((row) => ({
+			...row,
+			labels: recipe.annotate(row, tokenize(row.input, recipe.tokenizer))
+		})))),
+		supervisedTokens: fit.supervisedTokens,
+		loss: fit.history,
+		exportParity: fit.parity,
+		validation,
+		evaluation: await evaluateSequence$1(parser(fit.model), project.evaluation),
+		challenges: challenges ? await evaluateSequence$1(parser(fit.model), challenges) : null,
+		trainingMs: performance.now() - started,
+		notes: "Float32 weights in a Burn binary record, base64-encoded in the artifact. Validation gates export. Eval labels do not influence selection. Scores are uncalibrated."
+	};
+	await packageModel(project.output, fit.model, report);
+	return {
+		report,
+		output: project.output
+	};
+}
+//#endregion
+export { runSequence };
+
+//# sourceMappingURL=sequence-DGoGU7kG.js.map

package/dist/sequence-DGoGU7kG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-DGoGU7kG.js","names":["evaluateSequence","evaluate"],"sources":["../src/native/fit.ts","../src/models/sequence/prepare-supervision.ts","../src/models/sequence/fit-sequence.ts","../src/models/sequence/run-sequence.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\ninterface NativeResult {\n  parameters: number;\n  weights: Uint8Array;\n  loss: number[];\n}\nconst require = createRequire(import.meta.url);\nexport function predict(\n  config: { vocabularySize: number; labelCount: number },\n  weights: Uint8Array,\n  inputs: number[][],\n): number[] {\n  const native = require(\"#native\") as {\n    predict(config: string, weights: Buffer, inputs: Int32Array): number[];\n  };\n  return native.predict(\n    JSON.stringify(config),\n    Buffer.from(weights),\n    Int32Array.from(inputs.flat()),\n  );\n}\nexport function fit(\n  config: { vocabularySize: number; labelCount: number },\n  inputs: number[][],\n  labels: number[],\n  progress?: (epoch: number, loss: number) => void,\n): Promise<NativeResult> {\n  const native = require(\"#native\") as {\n    fit(\n      config: string,\n      inputs: Int32Array,\n      labels: Int32Array,\n      progress: (error: Error | null, value: number[]) => void,\n    ): Promise<NativeResult>;\n  };\n  return native.fit(\n    JSON.stringify(config),\n    Int32Array.from(inputs.flat()),\n    Int32Array.from(labels),\n    (error, value) => {\n      if (!error) {\n        progress?.(value[0]!, value[1]!);\n      }\n    },\n  );\n}\n","import { tokenize, windows } from \"@matchbox-ai/core/internal\";\nimport type { DatasetExample } from \"@matchbox-ai/core\";\nimport type { SequenceRecipe } from \"./types.js\";\nexport function prepareSupervision(\n  examples: readonly DatasetExample<unknown>[],\n  recipe: SequenceRecipe,\n) {\n  const vocabulary = [\n    ...new Set(\n      examples.flatMap((row) => tokenize(row.input, recipe.tokenizer).map((token) => token.key)),\n    ),\n  ].sort();\n  const radius = 1;\n  const dropout = recipe.tokenDropout ?? 0;\n  if (!Number.isFinite(dropout) || dropout < 0 || dropout > 0.5) {\n    throw new Error(\"tokenDropout must be between 0 and 0.5.\");\n  }\n  let maskingSeed = 7043;\n  const random = () => {\n    maskingSeed = (Math.imul(maskingSeed, 1664525) + 1013904223) >>> 0;\n    return maskingSeed / 4294967296;\n  };\n  const inputs: number[][] = [];\n  const labels: number[] = [];\n  for (const example of examples) {\n    const tokens = tokenize(example.input, recipe.tokenizer);\n    const annotations = recipe.annotate(example, tokens);\n    if (annotations.length !== tokens.length) {\n      throw new Error(`Annotation length mismatch: ${example.input}`);\n    }\n    windows(tokens, vocabulary, radius).forEach((window, position) => {\n      const label = annotations[position];\n      if (label === null) {\n        return;\n      }\n      const id = recipe.labels.indexOf(label!);\n      if (id < 0) {\n        throw new Error(`Unknown annotation ${label}: ${example.input}`);\n      }\n      inputs.push(window);\n      labels.push(id);\n      if (dropout > 0) {\n        inputs.push(window.map((id) => (id > 1 && random() < dropout ? 1 : id)));\n        labels.push(id);\n      }\n    });\n  }\n  if (recipe.labels.some((_, id) => !labels.includes(id))) {\n    throw new Error(\"Every label needs supervised training examples.\");\n  }\n  // Mix currency/template blocks deterministically before minibatch optimization.\n  maskingSeed = 9187;\n  for (let index = inputs.length - 1; index > 0; index--) {\n    const other = Math.floor(random() * (index + 1));\n    [inputs[index], inputs[other]] = [inputs[other]!, inputs[index]!];\n    [labels[index], labels[other]] = [labels[other]!, labels[index]!];\n  }\n  return { vocabulary, radius, dropout, inputs, labels };\n}\n","import { prepareSupervision } from \"./prepare-supervision.js\";\nimport { fit, predict } from \"../../native/index.js\";\nimport { tensorPredictor, tokenize, windows } from \"@matchbox-ai/core/internal\";\nimport type { SequenceArtifact } from \"@matchbox-ai/core/internal\";\nimport type { DatasetExample } from \"@matchbox-ai/core\";\nimport type { SequenceRecipe } from \"./types.js\";\nexport async function fitSequence(\n  examples: readonly DatasetExample<unknown>[],\n  recipe: SequenceRecipe,\n  metadata: Pick<SequenceArtifact, \"taskModule\" | \"taskMetadata\" | \"decoderModule\">,\n  probes: readonly string[] = [],\n  progress?: (epoch: number, loss: number) => void,\n) {\n  const { vocabulary, radius, dropout, inputs, labels } = prepareSupervision(examples, recipe);\n  const result = await fit(\n    { vocabularySize: vocabulary.length + 2, labelCount: recipe.labels.length },\n    inputs,\n    labels,\n    progress,\n  );\n  const artifact = (weights: Uint8Array): SequenceArtifact => ({\n    formatVersion: 3,\n    engine: \"burn-0.21\",\n    kind: \"sequence-parser\",\n    architecture: \"embedding-window-mlp\",\n    ...metadata,\n    tokenizer: recipe.tokenizer,\n    readout: recipe.readout,\n    vocabulary,\n    labels: [...recipe.labels],\n    radius: radius as 1,\n    unknownTokens: dropout > 0 ? \"predict\" : \"abstain\",\n    threshold: 0.75,\n    precision: \"float32\",\n    weights: Buffer.from(weights).toString(\"base64\"),\n  });\n  const model = artifact(result.weights);\n  const checked = [...examples.slice(0, 16).map((row) => row.input), ...probes];\n  const portable = await tensorPredictor(model);\n  let maxConfidenceError = 0;\n  let labelDisagreements = 0;\n  try {\n    for (const input of checked) {\n      const tokens = tokenize(input, recipe.tokenizer);\n      if (!tokens.length) {\n        continue;\n      }\n      const scores = predict(\n        { vocabularySize: vocabulary.length + 2, labelCount: recipe.labels.length },\n        result.weights,\n        windows(tokens, vocabulary, radius),\n      );\n      portable.sequence(input).forEach((token, index) => {\n        const row = scores.slice(index * recipe.labels.length, (index + 1) * recipe.labels.length);\n        const confidence = Math.max(...row);\n        maxConfidenceError = Math.max(maxConfidenceError, Math.abs(confidence - token.confidence));\n        if (recipe.labels[row.indexOf(confidence)] !== token.label) {\n          labelDisagreements++;\n        }\n      });\n    }\n  } finally {\n    portable.dispose();\n  }\n  if (labelDisagreements || maxConfidenceError > 1e-5) {\n    throw new Error(\"Burn native and WASM predictions disagree.\");\n  }\n  return {\n    model,\n    parameters: result.parameters,\n    history: result.loss,\n    parity: { examples: checked.length, maxConfidenceError, labelDisagreements },\n    supervisedTokens: inputs.length,\n  };\n}\n","import { sameOutput } from \"../../evaluation/same-output.js\";\nimport { z } from \"zod\";\nimport { createHash } from \"node:crypto\";\nimport { readFile } from \"node:fs/promises\";\nimport { dirname, relative, resolve } from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\nimport { createParser } from \"@matchbox-ai/core/runtime\";\nimport { readSequenceArtifact, tokenize } from \"@matchbox-ai/core/internal\";\nimport type { DatasetExample } from \"@matchbox-ai/core\";\nimport type { MatchboxParser, SequenceDecoder } from \"@matchbox-ai/core/runtime\";\nimport type { loadProject } from \"../../load-project.js\";\nimport { packageModel } from \"../../packaging/package-model.js\";\nimport { fitSequence } from \"./fit-sequence.js\";\nimport { evaluateSequence as evaluate } from \"../../evaluation/evaluate-sequence.js\";\nimport type { SequenceRecipe } from \"./types.js\";\nconst hash = (value: string) => createHash(\"sha256\").update(value).digest(\"hex\");\nexport async function runSequence(\n  command: \"train\" | \"eval\",\n  project: Awaited<ReturnType<typeof loadProject>>,\n  progress?: (epoch: number, loss: number) => void,\n) {\n  const { task, config } = project;\n  const root = project.root;\n  const sequence = config.sequence;\n  if (!sequence) {\n    throw new Error(\"A sequence pipeline needs both recipe and decoder modules.\");\n  }\n  const savedArtifact =\n    command === \"eval\"\n      ? readSequenceArtifact(JSON.parse(await readFile(project.output, \"utf8\")))\n      : null;\n  const decoderPath = savedArtifact\n    ? resolve(dirname(project.output), savedArtifact.decoderModule)\n    : resolve(root, sequence.decoder);\n  const decode: SequenceDecoder = (await import(pathToFileURL(decoderPath).href)).default;\n  const evaluateSequence = (\n    parser: MatchboxParser<unknown>,\n    examples: readonly DatasetExample<unknown>[],\n  ) =>\n    evaluate(parser, examples, (value) => task.validateOutput(value).success).finally(() => {\n      if (\"dispose\" in parser && typeof parser.dispose === \"function\") {\n        parser.dispose();\n      }\n    });\n  const parser = (artifact: unknown) => createParser(artifact, task, decode);\n  if (savedArtifact) {\n    return { evaluation: await evaluateSequence(parser(savedArtifact), project.evaluation) };\n  }\n  const recipe: SequenceRecipe = (await import(pathToFileURL(resolve(root, sequence.recipe)).href))\n    .default;\n  const modulePath = (path: string) => {\n    const value = relative(dirname(project.output), path).replaceAll(\"\\\\\", \"/\");\n    return value.startsWith(\".\") ? value : `./${value}`;\n  };\n  const rejections = z\n    .array(z.strictObject({ input: z.string(), output: z.null() }))\n    .parse(recipe.rejections ?? []);\n  const training = [...project.train, ...rejections];\n  const heldOut = new Set(\n    [...project.validation, ...project.evaluation].map((row) => row.input.trim().toLowerCase()),\n  );\n  for (const example of training) {\n    if (!task.validateInput(example.input).success) {\n      throw new Error(`Invalid training input: ${example.input}`);\n    }\n    if (heldOut.has(example.input.trim().toLowerCase())) {\n      throw new Error(`Training input overlaps evaluation: ${example.input}`);\n    }\n    const tokens = tokenize(example.input, recipe.tokenizer);\n    const labels = recipe.annotate(example, tokens);\n    const value = decode(\n      tokens.map((token, index) => ({ ...token, label: labels[index] ?? \"O\", confidence: 1 })),\n      example.input,\n    );\n    if (!sameOutput(value, example.output)) {\n      throw new Error(\n        `Training annotations do not decode to the supplied output: ${example.input}`,\n      );\n    }\n  }\n  const started = performance.now();\n  const fit = await fitSequence(\n    training,\n    recipe,\n    {\n      taskMetadata: task.toJSON(),\n      taskModule: modulePath(project.taskPath),\n      decoderModule: modulePath(resolve(root, sequence.decoder)),\n    },\n    project.validation.map((row) => row.input),\n    progress,\n  );\n  const validation = await evaluateSequence(parser(fit.model), project.validation);\n  const bytes = Buffer.byteLength(JSON.stringify(fit.model));\n  if (validation.exactAccuracy < config.minAccuracy || bytes > config.maxBytes) {\n    throw new Error(\n      `Sequence model failed validation/size requirements (${validation.exactAccuracy}, ${bytes} bytes). ${JSON.stringify(validation.failures.slice(0, 10))}`,\n    );\n  }\n  const challenges = config.challenges\n    ? z\n        .array(z.strictObject({ input: z.string(), output: z.null() }))\n        .min(1)\n        .parse(JSON.parse(await readFile(resolve(root, config.challenges), \"utf8\")))\n    : null;\n  const report = {\n    formatVersion: 2,\n    architecture: fit.model.architecture,\n    backend: \"Burn native CPU\",\n    seed: 42,\n    artifactSha256: hash(JSON.stringify(fit.model)),\n    bytes,\n    parameters: fit.parameters,\n    datasetSha256: project.sources.map((source) => ({\n      source: source.source,\n      sha256: hash(source.text),\n    })),\n    examples: {\n      train: project.train.length,\n      rejections: recipe.rejections?.length ?? 0,\n      validation: project.validation.length,\n      eval: project.evaluation.length,\n    },\n    supervisionSha256: hash(\n      JSON.stringify(\n        training.map((row) => ({\n          ...row,\n          labels: recipe.annotate(row, tokenize(row.input, recipe.tokenizer)),\n        })),\n      ),\n    ),\n    supervisedTokens: fit.supervisedTokens,\n    loss: fit.history,\n    exportParity: fit.parity,\n    validation,\n    evaluation: await evaluateSequence(parser(fit.model), project.evaluation),\n    challenges: challenges ? await evaluateSequence(parser(fit.model), challenges) : null,\n    trainingMs: performance.now() - started,\n    notes:\n      \"Float32 weights in a Burn binary record, base64-encoded in the artifact. Validation gates export. Eval labels do not influence selection. Scores are uncalibrated.\",\n  };\n  await packageModel(project.output, fit.model, report);\n  return { report, output: project.output };\n}\n"],"mappings":";;;;;;;;;;;AAMA,MAAM,UAAU,cAAc,YAAY,GAAG;AAC7C,SAAgB,QACd,QACA,SACA,QACU;CAIV,OAHe,QAAQ,SAGX,CAAC,CAAC,QACZ,KAAK,UAAU,MAAM,GACrB,OAAO,KAAK,OAAO,GACnB,WAAW,KAAK,OAAO,KAAK,CAAC,CAC/B;AACF;AACA,SAAgB,IACd,QACA,QACA,QACA,UACuB;CASvB,OARe,QAAQ,SAQX,CAAC,CAAC,IACZ,KAAK,UAAU,MAAM,GACrB,WAAW,KAAK,OAAO,KAAK,CAAC,GAC7B,WAAW,KAAK,MAAM,IACrB,OAAO,UAAU;EAChB,IAAI,CAAC,OACH,WAAW,MAAM,IAAK,MAAM,EAAG;CAEnC,CACF;AACF;;;AC1CA,SAAgB,mBACd,UACA,QACA;CACA,MAAM,aAAa,CACjB,GAAG,IAAI,IACL,SAAS,SAAS,QAAQ,SAAS,IAAI,OAAO,OAAO,SAAS,CAAC,CAAC,KAAK,UAAU,MAAM,GAAG,CAAC,CAC3F,CACF,CAAC,CAAC,KAAK;CACP,MAAM,SAAS;CACf,MAAM,UAAU,OAAO,gBAAgB;CACvC,IAAI,CAAC,OAAO,SAAS,OAAO,KAAK,UAAU,KAAK,UAAU,IACxD,MAAM,IAAI,MAAM,yCAAyC;CAE3D,IAAI,cAAc;CAClB,MAAM,eAAe;EACnB,cAAe,KAAK,KAAK,aAAa,OAAO,IAAI,eAAgB;EACjE,OAAO,cAAc;CACvB;CACA,MAAM,SAAqB,CAAC;CAC5B,MAAM,SAAmB,CAAC;CAC1B,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,SAAS,SAAS,QAAQ,OAAO,OAAO,SAAS;EACvD,MAAM,cAAc,OAAO,SAAS,SAAS,MAAM;EACnD,IAAI,YAAY,WAAW,OAAO,QAChC,MAAM,IAAI,MAAM,+BAA+B,QAAQ,OAAO;EAEhE,QAAQ,QAAQ,YAAY,MAAM,CAAC,CAAC,SAAS,QAAQ,aAAa;GAChE,MAAM,QAAQ,YAAY;GAC1B,IAAI,UAAU,MACZ;GAEF,MAAM,KAAK,OAAO,OAAO,QAAQ,KAAM;GACvC,IAAI,KAAK,GACP,MAAM,IAAI,MAAM,sBAAsB,MAAM,IAAI,QAAQ,OAAO;GAEjE,OAAO,KAAK,MAAM;GAClB,OAAO,KAAK,EAAE;GACd,IAAI,UAAU,GAAG;IACf,OAAO,KAAK,OAAO,KAAK,OAAQ,KAAK,KAAK,OAAO,IAAI,UAAU,IAAI,EAAG,CAAC;IACvE,OAAO,KAAK,EAAE;GAChB;EACF,CAAC;CACH;CACA,IAAI,OAAO,OAAO,MAAM,GAAG,OAAO,CAAC,OAAO,SAAS,EAAE,CAAC,GACpD,MAAM,IAAI,MAAM,iDAAiD;CAGnE,cAAc;CACd,KAAK,IAAI,QAAQ,OAAO,SAAS,GAAG,QAAQ,GAAG,SAAS;EACtD,MAAM,QAAQ,KAAK,MAAM,OAAO,KAAK,QAAQ,EAAE;EAC/C,CAAC,OAAO,QAAQ,OAAO,UAAU,CAAC,OAAO,QAAS,OAAO,MAAO;EAChE,CAAC,OAAO,QAAQ,OAAO,UAAU,CAAC,OAAO,QAAS,OAAO,MAAO;CAClE;CACA,OAAO;EAAE;EAAY;EAAQ;EAAS;EAAQ;CAAO;AACvD;;;ACpDA,eAAsB,YACpB,UACA,QACA,UACA,SAA4B,CAAC,GAC7B,UACA;CACA,MAAM,EAAE,YAAY,QAAQ,SAAS,QAAQ,WAAW,mBAAmB,UAAU,MAAM;CAC3F,MAAM,SAAS,MAAM,IACnB;EAAE,gBAAgB,WAAW,SAAS;EAAG,YAAY,OAAO,OAAO;CAAO,GAC1E,QACA,QACA,QACF;CACA,MAAM,YAAY,aAA2C;EAC3D,eAAe;EACf,QAAQ;EACR,MAAM;EACN,cAAc;EACd,GAAG;EACH,WAAW,OAAO;EAClB,SAAS,OAAO;EAChB;EACA,QAAQ,CAAC,GAAG,OAAO,MAAM;EACjB;EACR,eAAe,UAAU,IAAI,YAAY;EACzC,WAAW;EACX,WAAW;EACX,SAAS,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,QAAQ;CACjD;CACA,MAAM,QAAQ,SAAS,OAAO,OAAO;CACrC,MAAM,UAAU,CAAC,GAAG,SAAS,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,QAAQ,IAAI,KAAK,GAAG,GAAG,MAAM;CAC5E,MAAM,WAAW,MAAM,gBAAgB,KAAK;CAC5C,IAAI,qBAAqB;CACzB,IAAI,qBAAqB;CACzB,IAAI;EACF,KAAK,MAAM,SAAS,SAAS;GAC3B,MAAM,SAAS,SAAS,OAAO,OAAO,SAAS;GAC/C,IAAI,CAAC,OAAO,QACV;GAEF,MAAM,SAAS,QACb;IAAE,gBAAgB,WAAW,SAAS;IAAG,YAAY,OAAO,OAAO;GAAO,GAC1E,OAAO,SACP,QAAQ,QAAQ,YAAY,MAAM,CACpC;GACA,SAAS,SAAS,KAAK,CAAC,CAAC,SAAS,OAAO,UAAU;IACjD,MAAM,MAAM,OAAO,MAAM,QAAQ,OAAO,OAAO,SAAS,QAAQ,KAAK,OAAO,OAAO,MAAM;IACzF,MAAM,aAAa,KAAK,IAAI,GAAG,GAAG;IAClC,qBAAqB,KAAK,IAAI,oBAAoB,KAAK,IAAI,aAAa,MAAM,UAAU,CAAC;IACzF,IAAI,OAAO,OAAO,IAAI,QAAQ,UAAU,OAAO,MAAM,OACnD;GAEJ,CAAC;EACH;CACF,UAAU;EACR,SAAS,QAAQ;CACnB;CACA,IAAI,sBAAsB,qBAAqB,MAC7C,MAAM,IAAI,MAAM,4CAA4C;CAE9D,OAAO;EACL;EACA,YAAY,OAAO;EACnB,SAAS,OAAO;EAChB,QAAQ;GAAE,UAAU,QAAQ;GAAQ;GAAoB;EAAmB;EAC3E,kBAAkB,OAAO;CAC3B;AACF;;;AC3DA,MAAM,QAAQ,UAAkB,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK;AAC/E,eAAsB,YACpB,SACA,SACA,UACA;CACA,MAAM,EAAE,MAAM,WAAW;CACzB,MAAM,OAAO,QAAQ;CACrB,MAAM,WAAW,OAAO;CACxB,IAAI,CAAC,UACH,MAAM,IAAI,MAAM,4DAA4D;CAE9E,MAAM,gBACJ,YAAY,SACR,qBAAqB,KAAK,MAAM,MAAM,SAAS,QAAQ,QAAQ,MAAM,CAAC,CAAC,IACvE;CACN,MAAM,cAAc,gBAChB,QAAQ,QAAQ,QAAQ,MAAM,GAAG,cAAc,aAAa,IAC5D,QAAQ,MAAM,SAAS,OAAO;CAClC,MAAM,UAA2B,MAAM,OAAO,cAAc,WAAW,CAAC,CAAC,MAAA,CAAO;CAChF,MAAMA,sBACJ,QACA,aAEAC,iBAAS,QAAQ,WAAW,UAAU,KAAK,eAAe,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,cAAc;EACtF,IAAI,aAAa,UAAU,OAAO,OAAO,YAAY,YACnD,OAAO,QAAQ;CAEnB,CAAC;CACH,MAAM,UAAU,aAAsB,aAAa,UAAU,MAAM,MAAM;CACzE,IAAI,eACF,OAAO,EAAE,YAAY,MAAMD,mBAAiB,OAAO,aAAa,GAAG,QAAQ,UAAU,EAAE;CAEzF,MAAM,UAA0B,MAAM,OAAO,cAAc,QAAQ,MAAM,SAAS,MAAM,CAAC,CAAC,CAAC,MAAA,CACxF;CACH,MAAM,cAAc,SAAiB;EACnC,MAAM,QAAQ,SAAS,QAAQ,QAAQ,MAAM,GAAG,IAAI,CAAC,CAAC,WAAW,MAAM,GAAG;EAC1E,OAAO,MAAM,WAAW,GAAG,IAAI,QAAQ,KAAK;CAC9C;CACA,MAAM,aAAa,EAChB,MAAM,EAAE,aAAa;EAAE,OAAO,EAAE,OAAO;EAAG,QAAQ,EAAE,KAAK;CAAE,CAAC,CAAC,CAAC,CAC9D,MAAM,OAAO,cAAc,CAAC,CAAC;CAChC,MAAM,WAAW,CAAC,GAAG,QAAQ,OAAO,GAAG,UAAU;CACjD,MAAM,UAAU,IAAI,IAClB,CAAC,GAAG,QAAQ,YAAY,GAAG,QAAQ,UAAU,CAAC,CAAC,KAAK,QAAQ,IAAI,MAAM,KAAK,CAAC,CAAC,YAAY,CAAC,CAC5F;CACA,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,CAAC,KAAK,cAAc,QAAQ,KAAK,CAAC,CAAC,SACrC,MAAM,IAAI,MAAM,2BAA2B,QAAQ,OAAO;EAE5D,IAAI,QAAQ,IAAI,QAAQ,MAAM,KAAK,CAAC,CAAC,YAAY,CAAC,GAChD,MAAM,IAAI,MAAM,uCAAuC,QAAQ,OAAO;EAExE,MAAM,SAAS,SAAS,QAAQ,OAAO,OAAO,SAAS;EACvD,MAAM,SAAS,OAAO,SAAS,SAAS,MAAM;EAC9C,MAAM,QAAQ,OACZ,OAAO,KAAK,OAAO,WAAW;GAAE,GAAG;GAAO,OAAO,OAAO,UAAU;GAAK,YAAY;EAAE,EAAE,GACvF,QAAQ,KACV;EACA,IAAI,CAAC,WAAW,OAAO,QAAQ,MAAM,GACnC,MAAM,IAAI,MACR,8DAA8D,QAAQ,OACxE;CAEJ;CACA,MAAM,UAAU,YAAY,IAAI;CAChC,MAAM,MAAM,MAAM,YAChB,UACA,QACA;EACE,cAAc,KAAK,OAAO;EAC1B,YAAY,WAAW,QAAQ,QAAQ;EACvC,eAAe,WAAW,QAAQ,MAAM,SAAS,OAAO,CAAC;CAC3D,GACA,QAAQ,WAAW,KAAK,QAAQ,IAAI,KAAK,GACzC,QACF;CACA,MAAM,aAAa,MAAMA,mBAAiB,OAAO,IAAI,KAAK,GAAG,QAAQ,UAAU;CAC/E,MAAM,QAAQ,OAAO,WAAW,KAAK,UAAU,IAAI,KAAK,CAAC;CACzD,IAAI,WAAW,gBAAgB,OAAO,eAAe,QAAQ,OAAO,UAClE,MAAM,IAAI,MACR,uDAAuD,WAAW,cAAc,IAAI,MAAM,WAAW,KAAK,UAAU,WAAW,SAAS,MAAM,GAAG,EAAE,CAAC,GACtJ;CAEF,MAAM,aAAa,OAAO,aACtB,EACG,MAAM,EAAE,aAAa;EAAE,OAAO,EAAE,OAAO;EAAG,QAAQ,EAAE,KAAK;CAAE,CAAC,CAAC,CAAC,CAC9D,IAAI,CAAC,CAAC,CACN,MAAM,KAAK,MAAM,MAAM,SAAS,QAAQ,MAAM,OAAO,UAAU,GAAG,MAAM,CAAC,CAAC,IAC7E;CACJ,MAAM,SAAS;EACb,eAAe;EACf,cAAc,IAAI,MAAM;EACxB,SAAS;EACT,MAAM;EACN,gBAAgB,KAAK,KAAK,UAAU,IAAI,KAAK,CAAC;EAC9C;EACA,YAAY,IAAI;EAChB,eAAe,QAAQ,QAAQ,KAAK,YAAY;GAC9C,QAAQ,OAAO;GACf,QAAQ,KAAK,OAAO,IAAI;EAC1B,EAAE;EACF,UAAU;GACR,OAAO,QAAQ,MAAM;GACrB,YAAY,OAAO,YAAY,UAAU;GACzC,YAAY,QAAQ,WAAW;GAC/B,MAAM,QAAQ,WAAW;EAC3B;EACA,mBAAmB,KACjB,KAAK,UACH,SAAS,KAAK,SAAS;GACrB,GAAG;GACH,QAAQ,OAAO,SAAS,KAAK,SAAS,IAAI,OAAO,OAAO,SAAS,CAAC;EACpE,EAAE,CACJ,CACF;EACA,kBAAkB,IAAI;EACtB,MAAM,IAAI;EACV,cAAc,IAAI;EAClB;EACA,YAAY,MAAMA,mBAAiB,OAAO,IAAI,KAAK,GAAG,QAAQ,UAAU;EACxE,YAAY,aAAa,MAAMA,mBAAiB,OAAO,IAAI,KAAK,GAAG,UAAU,IAAI;EACjF,YAAY,YAAY,IAAI,IAAI;EAChC,OACE;CACJ;CACA,MAAM,aAAa,QAAQ,QAAQ,IAAI,OAAO,MAAM;CACpD,OAAO;EAAE;EAAQ,QAAQ,QAAQ;CAAO;AAC1C"}

package/dist/train.d.ts

@@ -34,23 +34,11 @@ export declare function train(target: string, options?: {
         }[];
         examples: {
             train: number;
+            rejections: 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;
+        supervisionSha256: string;
         supervisedTokens: number;
         loss: number[];
         exportParity: {
@@ -72,49 +60,7 @@ export declare function train(target: string, options?: {
                 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: {
+        evaluation: {
             examples: number;
             invalidOutputRate: number;
             exactAccuracy: number;
@@ -142,20 +88,6 @@ export declare function train(target: string, options?: {
                 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;
     };
@@ -198,35 +130,7 @@ export declare function train(target: string, options?: {
                 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: {
+        evaluation: {
             examples: number;
             invalidOutputRate: number;
             exactAccuracy: number;
@@ -240,34 +144,6 @@ export declare function train(target: string, options?: {
                 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;
     };

package/dist/train.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"train.d.ts","sourceRoot":"","sources":["../src/train.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,wBAAsB,KAAK,CACzB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKrE"}
+{"version":3,"file":"train.d.ts","sourceRoot":"","sources":["../src/train.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,wBAAsB,KAAK,CACzB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKrE"}

package/dist/types.d.ts

@@ -1,11 +1,9 @@
 export interface TrainingConfig {
-    formatVersion?: 1;
     challenges?: string;
     sequence?: {
         recipe: string;
         decoder: string;
     };
-    baseline?: string;
     task?: string;
     train?: string;
     validation?: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,CAAC,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/docs/README.md

@@ -1,9 +1,14 @@
 # Matchbox documentation
 
-Start with [getting started](getting-started.md), then read [project structure](project-structure.md), [pipelines](pipelines.md), and [evaluation](evaluation.md).
-
-The [primitive reference](primitives/README.md) describes supported authoring choices. [React](react.md), [browser runtime](runtime-backends.md), and [CLI](cli.md) cover application integration and local development. [Repository design](repository-design.md) is for contributors.
-
-These docs ship in all three packages under node_modules/@matchbox-ai/{core,train}/docs and node_modules/matchbox-ai/docs. Use the installed version when assisting an application author. The bundled agent-skill.md provides the corresponding coding-agent workflow.
-
-See [Releases](releases.md) for Changesets, package versions, and npm publishing.
+Start with [Getting started](getting-started.md) to add a task, train a model, and import it into an existing app.
+
+- [CLI reference](cli.md) covers every command and option.
+- [API reference](reference/README.md) indexes the public contracts by package.
+- [Training](training.md) walks through fitting and exporting a model.
+- [Training pipelines](pipelines.md) explains the two learning strategies and their limits.
+- [Project structure](project-structure.md) maps authored files and generated artifacts.
+- [Evaluation](evaluation.md) explains validation gates, test data, and uncertainty.
+- [Example results](example-evaluation.md) reports harder cases, coverage, and remaining failures.
+- [Money](examples/money.md) and [time](examples/time.md) show token recognition with explicit application-owned decoding.
+
+Matchbox currently accepts string inputs. Core owns validation and browser integration; train owns build-time orchestration; Burn owns training and execution.

package/docs/agent-skill.md

@@ -7,16 +7,20 @@ description: Author, train, evaluate, and integrate tiny browser-local Matchbox
 
 Read the installed package docs/README.md first, then project-structure.md, pipelines.md, evaluation.md, and primitives/README.md. In the framework repository, use root docs/. Match examples to the installed version.
 
-1. Inspect parser.ts, pipeline.ts, data/train.jsonl, and independent evals before changing behavior.
+1. Inspect parser, pipeline, recipe, and decode entry points (`X.ts` or `X/X.ts`), data/train.jsonl, and independent evals before changing behavior.
 2. Keep the output schema focused on valid application values. Make representation and supervision choices explicit in pipeline.ts or imported helpers.
 3. Use fieldClassifier for finite output domains and tokenClassifier for explicitly supervised token recognition. Explain their limits; do not promise unseen numeric outputs from a finite classifier.
 4. Keep domain dictionaries and normalizers application-owned and visible. Never insert one silently to make an evaluation pass.
 5. Fit preprocessing only on training data. Put data generators in project-level scripts/ and preserve validation/test fixtures. Add meaningful held-out compositions and negative cases independently of model fitting.
 6. Use the CLI from matchbox-ai or programmatic train from @matchbox-ai/train to apply validation gates, measure results, and package weights. Report failures honestly. Never fabricate benchmark figures.
 7. Distinguish uncertain interpretation from invalid user input. Confidence is currently uncalibrated; inspect diagnostics before attributing uncertainty to one cause.
-8. Import generated artifacts in the app and use @matchbox-ai/core/react when needed. Keep @matchbox-ai/train and native TensorFlow outside browser code.
-9. Let TensorFlow serialize, load, and execute models. Do not implement custom inference kernels or a backend-selection framework. Verify native-to-browser export parity and benchmark the shipped TensorFlow runtime. Label emulated mobile measurements accurately.
+8. Import generated artifacts in the app and use @matchbox-ai/core/react when needed. Keep @matchbox-ai/train and native Burn outside browser code.
+9. Let Burn serialize, load, and execute models. Do not implement custom inference kernels or a backend-selection framework. Verify native-to-browser export parity and benchmark the shipped Burn runtime. Label emulated mobile measurements accurately.
 
 Scope changes to existing, documented primitives. Propose a new primitive separately with its contract, limitations, and evaluation evidence. Preserve authored code and tests when reorganizing folders.
 
-Matchbox owns authoring, workflows, evals, packaging, validation, and typed results. TensorFlow owns model execution. A schema must never silently select numeric encodings or domain normalizers.
+Matchbox owns authoring, workflows, evals, packaging, validation, and typed results. Burn owns model execution. A schema must never silently select numeric encodings or domain normalizers.
+
+## Task layout
+
+Use `X.ts` or `X/X.ts` for parser, pipeline, recipe, and decode. Keep helper files with their owning module. Shared domain code belongs in a named task-level folder. No task or helper index barrel is required. `tokenClassifier()` discovers recipe and decode; explicit path overrides are relative to the task root. Never keep both entry forms. Retrain after relocating authored modules because artifacts reference concrete source paths.