@genai-fi/nanogpt 0.24.0 → 1.0.0

package/dist/training/BasicTrainer.js

@@ -1,16 +1,17 @@
 import { _n as e, di as t, kt as n, ni as r, oi as i, qt as a } from "../dist-Da20xy8E.js";
 import { AdamWOptimizer as o } from "./AdamW.js";
-import { calculateAccuracy as s, calculateLoss as c } from "./loss.js";
-import l from "./Evaluator.js";
-import u from "../utilities/profile.js";
+import s from "../utilities/profile.js";
+import { calculateAccuracy as c, calculateLoss as l } from "./loss.js";
+import u from "./Evaluator.js";
 import { createTensorStatistics as d } from "../checks/weights.js";
+import f from "./configure.js";
 //#region lib/training/BasicTrainer.ts
-var f = {
+var p = {
 	logInterval: 1,
 	maxEpochs: 100,
-	sftMode: "full",
+	method: { type: "pretraining" },
 	batchSize: 32
-}, p = {
+}, m = {
 	learningRate: 3e-4,
 	beta1: .9,
 	beta2: .99,
@@ -21,10 +22,11 @@ var f = {
 	epochSteps: 1e4,
 	minLearningRate: 1e-5,
 	lossScaling: 1
-}, m = class {
+}, h = class {
 	tokenizer;
 	model;
 	optimizer;
+	log = [];
 	running = !1;
 	lastState;
 	_gradientCheckpointing = !1;
@@ -35,9 +37,10 @@ var f = {
 	_labelSmoothing = 0;
 	_layerDrop = 0;
 	_dropout = 0;
+	_tokensProcessed = 0;
 	constructor(e, t, n, r) {
 		this.tokenizer = t, this.model = e, this.optimizerConfig = {
-			...p,
+			...m,
 			...n,
 			lossScaling: n?.lossScaling ?? e.lossScaling
 		};
@@ -68,8 +71,11 @@ var f = {
 	setMetrics(e) {
 		this.metrics = new Set(e);
 	}
+	configure(e) {
+		this.setGradientCheckpointing(e?.gradientCheckpointing || !1), this.setMixedPrecision(e?.mixedPrecision || !1), this.setLabelSmoothing(e?.labelSmoothing || 0), this.setDropout(e?.dropout || 0), this.setLayerDrop(e?.layerDrop || 0), this.lastState || this.setLearningRate(e?.learningRate || .001), f(this.model, e);
+	}
 	reset() {
-		this.lastState = void 0, this.running = !1;
+		this.lastState = void 0, this.running = !1, this.log = [];
 	}
 	stop() {
 		this.running = !1;
@@ -77,6 +83,9 @@ var f = {
 	get isRunning() {
 		return this.running;
 	}
+	get tokensProcessed() {
+		return this._tokensProcessed;
+	}
 	getOptimizer() {
 		return this.optimizer;
 	}
@@ -97,7 +106,7 @@ var f = {
 			trainingDuration: e.duration
 		});
 	}
-	trainStep(n, o, l = !1, u = !1) {
+	trainStep(n, o, s = !1, u = !1) {
 		return t(() => {
 			this.model.getProfiler()?.startMemory();
 			let { xs: t, ys: d } = o, { value: f, grads: p } = a(() => {
@@ -108,12 +117,12 @@ var f = {
 					dropout: this._dropout,
 					layerDrop: this._layerDrop,
 					ropePositionOffset: 0
-				}, t), a = c(r, d, this.maskedLoss, !1, this._labelSmoothing);
-				this.metrics.has("accuracy") && (n.accuracy = s(r, d), i(n.accuracy)), r.dispose();
+				}, t), a = l(r, d, this.maskedLoss, !1, this._labelSmoothing);
+				this.metrics.has("accuracy") && (n.accuracy = c(r, d), i(n.accuracy)), r.dispose();
 				let o = a.mul(e(this.optimizerConfig.lossScaling));
 				return a.dispose(), o;
 			});
-			if (l) this.model.getProfiler()?.endMemory("Training");
+			if (s) this.model.getProfiler()?.endMemory("Training");
 			else {
 				let e = this.optimizer.applyGradients(p);
 				this.metrics.has("gradientNorm") ? (n.gradientNorm = e, i(e)) : (n.gradientNorm = void 0, e.dispose());
@@ -152,76 +161,47 @@ var f = {
 			...this.lastState || {}
 		};
 	}
-	async stepDataset(e, t, n) {
-		let { logInterval: i = 10 } = {
-			...f,
-			...t
-		};
-		t.metrics && this.setMetrics(t.metrics);
-		let a = Date.now(), o = this.createEmptyState();
-		this.lastState = o, await this.dummyPass(), this.metrics.has("memoryUsage") && (this.model.getProfiler() || this.model.setProfiler(new u())), this.running = !0, o.logStartTime = a;
-		let s = n ? new l(this.model, n, this.maskedLoss) : void 0, c = await e.iterator();
-		try {
-			for (; this.running;) {
-				let e = await c.next();
-				if (e.done) break;
-				let n = e.value, r = this.trainStep(o, n, !1);
-				if (t.debug) {
-					let e = (await r.data())[0];
-					if (isNaN(e) || !isFinite(e)) throw console.error("Invalid loss value:", e), console.error("Batch xs:", n.xs.toString()), console.error("Batch ys:", n.ys.toString()), console.error("State:", o), Error("Loss is NaN or Infinity");
-					console.log(`Step ${o.step}: Loss = ${e}`);
-				}
-				n.xs.dispose(), n.ys.dispose(), o.step++, o.totalSteps++, o.step % i === 0 ? await this.performLogging(r, n.xs.shape[0], t, s) : (o.gradientNorm &&= (o.gradientNorm.dispose(), void 0), o.accuracy &&= (o.accuracy.dispose(), void 0)), r.dispose();
-			}
-		} catch (e) {
-			throw console.error("Training error:", e), e;
-		}
-		throw this.model.trainingState = {
-			steps: o.totalSteps,
-			learningRate: this.optimizer.lr,
-			batchSize: t.batchSize || 32,
-			loss: o.lastLoss,
-			tokensProcessed: o.totalSteps * (t.batchSize || 32) * this.model.config.blockSize,
-			duration: o.trainingDuration
-		}, r(), this.running = !1, Error("No log returned before training stopped.");
-	}
 	async performLogging(e, t, n, r) {
-		let i = n?.onStep, a = this.metrics.has("gradientStatistics"), o = (await e.data())[0], s = this.lastState;
-		s.lastLoss = o, s.trainingDuration += Date.now() - s.logStartTime;
-		let c = s.totalSteps * t * this.model.config.blockSize, l = {
+		let i = this.metrics.has("gradientStatistics"), a = this.lastState, o = [];
+		o.push(e.data()), o.push(a.accuracy ? a.accuracy.data() : null), o.push(a.gradientNorm ? a.gradientNorm.data() : null);
+		let s = await Promise.all(o), c = s[0]?.[0] ?? 0, l = s[1] ? s[1][0] : void 0, u = s[2] ? s[2][1] : void 0;
+		a.lastLoss = c, a.trainingDuration += Date.now() - a.logStartTime;
+		let f = a.totalSteps * t * this.model.config.blockSize;
+		this._tokensProcessed = f;
+		let p = {
 			trainingMetrics: {
-				loss: s.lastLoss,
-				perplexity: this.metrics.has("perplexity") ? Math.exp(s.lastLoss) : void 0,
-				accuracy: s.accuracy ? (await s.accuracy.data())[0] : void 0
+				loss: a.lastLoss,
+				perplexity: this.metrics.has("perplexity") ? Math.exp(a.lastLoss) : void 0,
+				accuracy: l
 			},
-			step: s.step,
-			time: Date.now() - s.logStartTime,
-			gradientNorm: s.gradientNorm ? (await s.gradientNorm.data())[1] : void 0,
+			step: a.step,
+			time: Date.now() - a.logStartTime,
+			gradientNorm: u,
 			batchSize: t,
 			learningRate: this.metrics.has("learningRate") ? this.optimizer.lr : void 0,
-			duration: s.trainingDuration,
-			totalTokens: c,
-			tokensPerSecond: c / (s.trainingDuration / 1e3),
+			duration: a.trainingDuration,
+			totalTokens: f,
+			tokensPerSecond: f / (a.trainingDuration / 1e3),
 			memoryUsage: this.metrics.has("memoryUsage") ? this.model.getProfiler()?.getPeakMemory() || 0 : void 0
 		};
-		if (s.gradientNorm &&= (s.gradientNorm.dispose(), void 0), s.accuracy &&= (s.accuracy.dispose(), void 0), this.model.trainingState = {
-			steps: s.totalSteps,
+		if (a.gradientNorm &&= (a.gradientNorm.dispose(), void 0), a.accuracy &&= (a.accuracy.dispose(), void 0), this.model.trainingState = {
+			steps: a.totalSteps,
 			learningRate: this.optimizer.lr,
 			batchSize: t,
-			loss: s.lastLoss,
-			tokensProcessed: c,
-			duration: s.trainingDuration
-		}, a && s.gradients) {
+			loss: a.lastLoss,
+			tokensProcessed: f,
+			duration: a.trainingDuration
+		}, i && a.gradients) {
 			let e = /* @__PURE__ */ new Map();
-			for (let [t, n] of Object.entries(s.gradients)) e.set(t, await d(n)), n.dispose();
-			l.gradientMetrics = e;
+			for (let [t, n] of Object.entries(a.gradients)) e.set(t, await d(n)), n.dispose();
+			p.gradientMetrics = e;
 		}
-		if (r) try {
-			let e = await r.evaluate(5);
-			Array.isArray(e) ? l.validationMetrics = {
+		if (n) try {
+			let e = await n.evaluate(5);
+			Array.isArray(e) ? p.validationMetrics = {
 				loss: e[0].loss,
 				accuracy: e[0].accuracy
-			} : (s.validationLosses.push(e.loss), l.validationMetrics = {
+			} : (a.validationLosses.push(e.loss), p.validationMetrics = {
 				accuracy: e.accuracy,
 				loss: e.loss,
 				perplexity: this.metrics.has("perplexity") ? Math.exp(e.loss) : void 0
@@ -229,37 +209,49 @@ var f = {
 		} catch (e) {
 			console.error("Validation error:", e);
 		}
-		i && await i(l), s.logStartTime = Date.now();
+		this.log.push(p), r && r(p), a.logStartTime = Date.now();
 	}
-	async trainOnDataset(e, t, n) {
-		let { logInterval: i = 10, maxEpochs: a = Infinity } = {
-			...f,
+	async trainOnDataset(e, t, n, i) {
+		let { logInterval: a = 10, maxEpochs: o = Infinity } = {
+			...p,
 			...t
-		}, o = a * (t?.epochSteps || 1e3);
+		};
+		this.log.length > 0 && this.resumeFromLog(this.log[this.log.length - 1]);
+		let c = o * (t?.epochSteps || 1e3);
 		t.metrics && this.setMetrics(t.metrics);
-		let s = Date.now(), c = this.createEmptyState();
-		this.lastState = c, await this.dummyPass(), t?.metrics?.includes("memoryUsage") && (this.model.getProfiler() || this.model.setProfiler(new u())), this.running = !0, c.logStartTime = s;
-		let d = n ? new l(this.model, n, this.maskedLoss) : void 0, p = await e.iterator();
+		let l = this.createEmptyState();
+		this.lastState = l, await this.dummyPass(), t?.metrics?.includes("memoryUsage") && (this.model.getProfiler() || this.model.setProfiler(new s()));
+		let d = Date.now();
+		this.running = !0, l.logStartTime = d;
+		let f = n ? new u(this.model, n, this.maskedLoss) : void 0, m = await e.iterator(), h = m.next();
 		try {
 			for (; this.running;) {
-				let e = await p.next();
-				if (e.done) break;
-				let n = e.value, r = c.step % i === 0, a = (t?.metrics?.includes("gradientStatistics") || !1) && r, s = this.trainStep(c, n, !1, a);
+				let e = await h;
+				if (h = m.next(), e.done) break;
+				let n = e.value, r = l.step % a === 0, o = (t?.metrics?.includes("gradientStatistics") || !1) && r, s = this.trainStep(l, n, !1, o);
 				if (t.debug) {
 					let e = (await s.data())[0];
-					if (isNaN(e) || !isFinite(e)) throw console.error("Invalid loss value:", e), console.error("Batch xs:", await n.xs.array()), console.error("Batch ys:", await n.ys.array()), console.error("State:", c), Error("Loss is NaN or Infinity");
-					console.log(`Step ${c.step}: Loss = ${e}`);
+					if (isNaN(e) || !isFinite(e)) throw console.error("Invalid loss value:", e), console.error("Batch xs:", await n.xs.array()), console.error("Batch ys:", await n.ys.array()), console.error("State:", l), Error("Loss is NaN or Infinity");
+					console.log(`Step ${l.step}: Loss = ${e}`);
 				}
-				n.xs.dispose(), n.ys.dispose(), c.step++, c.totalSteps++, r ? await this.performLogging(s, n.xs.shape[0], t, d) : (c.gradientNorm &&= (c.gradientNorm.dispose(), void 0), c.accuracy &&= (c.accuracy.dispose(), void 0)), s.dispose(), c.step >= o && this.stop();
+				n.xs.dispose(), n.ys.dispose(), l.step++, l.totalSteps++, r ? await this.performLogging(s, n.xs.shape[0], f, i) : (l.gradientNorm &&= (l.gradientNorm.dispose(), void 0), l.accuracy &&= (l.accuracy.dispose(), void 0)), s.dispose(), l.step >= c && this.stop();
 			}
 		} catch (e) {
 			throw console.error("Training error:", e), r(), e;
 		}
-		return r(), this.running = !1, {
-			losses: c.losses,
-			validationLosses: c.validationLosses
+		r(), this.running = !1, this.model.metaData.actionLog = this.model.metaData.actionLog || [];
+		let g = Date.now();
+		return this.model.metaData.actionLog.push({
+			action: "pretrain",
+			timestamp: g,
+			duration: g - d,
+			tokensProcessed: this.tokensProcessed,
+			options: t
+		}), {
+			losses: l.losses,
+			validationLosses: l.validationLosses
 		};
 	}
 };
 //#endregion
-export { m as default };
+export { h as default };

package/dist/training/configure.d.ts

@@ -0,0 +1,3 @@
+import { TrainingOptions } from './types';
+import { default as Model, ModelForwardAttributes } from '../../models/model';
+export default function configureModel(model: Model<ModelForwardAttributes>, options?: TrainingOptions): void;

package/dist/training/configure.js

@@ -0,0 +1,32 @@
+import { t as e } from "../v4-BK7K-jy_.js";
+//#region lib/training/configure.ts
+function t(t, n) {
+	let r = n?.method.supervised || "full", i = n?.method.type || "pretraining";
+	if (i === "pretraining" && (t.hasLoRA() && t.detachLoRA(), t.weightStore.setTrainable(["*"]), n && (t.metaData.pretrainingSettings = n)), i === "supervised") {
+		if (r === "lora") {
+			if (n?.loraName) {
+				if (!t.hasLoRA(n.loraName)) if (n.loraConfig) t.createLoRA(n.loraName, n.loraConfig), t.attachLoRA(n.loraName);
+				else throw Error(`LoRA configuration must be provided to create LoRA with name ${n.loraName}`);
+				else if (t.attachLoRA(n.loraName), n.loraConfig) {
+					let e = t.lora;
+					(e.alpha !== n.loraConfig.alpha || e.rank !== n.loraConfig.rank) && (t.detachLoRA(), t.deleteLoRA(n.loraName), t.createLoRA(n.loraName, n.loraConfig), t.attachLoRA(n.loraName), console.warn("Resetting LoRA with new configuration."));
+				}
+			} else if (n?.loraConfig) if (t.hasLoRA()) {
+				let r = t.lora;
+				if (r.alpha !== n.loraConfig.alpha || r.rank !== n.loraConfig.rank) {
+					t.detachLoRA();
+					let r = n.loraName || e();
+					t.createLoRA(r, n.loraConfig), t.attachLoRA(r);
+				}
+			} else {
+				let r = n.loraName || e();
+				t.createLoRA(r, n.loraConfig), t.attachLoRA(r);
+			}
+			else if (!t.hasLoRA()) throw Error("LoRA configuration must be provided for lora SFT mode");
+		} else t.hasLoRA() && t.detachLoRA();
+		r === "last-layer" ? t.weightStore.setTrainable([`block_${t.config.nLayer - 1}_*`, "token_embedding"]) : r === "full" && t.weightStore.setTrainable(["*"]);
+	}
+	n?.trainableWeights && t.weightStore.setTrainable(n.trainableWeights);
+}
+//#endregion
+export { t as default };

package/dist/training/factory.d.ts

@@ -0,0 +1,6 @@
+import { ModelForwardAttributes, default as Model } from '../../models/model';
+import { TrainingOptions } from '../../training/types';
+import { default as BasicTrainer } from '../../training/BasicTrainer';
+import { ITokeniser } from '../../tokeniser/type';
+import { AdamWOptimizer } from './AdamW';
+export default function createTrainer(model: Model<ModelForwardAttributes>, tokenizer: ITokeniser, options?: TrainingOptions, optimizer?: AdamWOptimizer): BasicTrainer;

package/dist/training/factory.js

@@ -0,0 +1,8 @@
+import e from "./SFTTrainer.js";
+import t from "./PreTrainer.js";
+//#region lib/training/factory.ts
+function n(n, r, i, a) {
+	return i?.method.type === "supervised" ? new e(n, r, i, a) : new t(n, r, i, a);
+}
+//#endregion
+export { n as default };

package/dist/training/prepareData.d.ts

@@ -0,0 +1,22 @@
+import { default as Model, ModelForwardAttributes } from '../../models/model';
+import { TrainingOptions } from './types';
+import { TokenStore } from './tasks/TokenStore';
+import { DatasetMetadata } from '../../loader/types';
+import { ConversationStream } from '../../data/stream';
+import { ITokeniser } from '../../tokeniser/type';
+import { Dataset } from '@tensorflow/tfjs-data';
+import { Tensor } from '@tensorflow/tfjs-core';
+interface PrepareDataResult {
+    trainDataset: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>;
+    validationDataset?: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>;
+    totalTokens: number;
+}
+/** Take our training options, model, tokeniser, and tasks, and prepare the training and validation datasets in Tensorflow format. */
+export default function prepareData(options: TrainingOptions, model: Model<ModelForwardAttributes>, tokeniser: ITokeniser, tasks: ConversationStream[] | Uint16Array[] | TokenStore, validation?: Uint16Array[] | TokenStore, datasets?: DatasetMetadata[]): Promise<PrepareDataResult>;
+export {};

package/dist/training/prepareData.js

@@ -0,0 +1,49 @@
+import { TokenStore as e } from "./tasks/TokenStore.js";
+import { tokensFromStreams as t } from "./tasks/tokenStream.js";
+import { t as n } from "../DatasetBuilder-DU1G1OKX.js";
+import { createTrainValidationDatasets as r, storeFromArray as i } from "./validation.js";
+//#region lib/training/prepareData.ts
+async function a(a, o, s, c, l, u) {
+	let d = a.loraName || a.loraConfig;
+	if (u && d) throw Error("Cannot specify datasets when using LoRA fine-tuning");
+	if (!u && !d) throw Error("Must specify datasets for non-LoRA training");
+	if (u) {
+		let e = o.metaData.pretrainingData || [], t = [...e], n = !1;
+		for (let r of u) e.some((e) => e.id === r.id) || t.push({
+			id: r.id,
+			name: r.name,
+			conversational: r.conversational
+		}), r.conversational && (n = !0);
+		o.metaData.pretrainingData = t, n ? o.metaData.mode = "conversational" : o.metaData.mode !== "conversational" && (o.metaData.mode = "completion");
+	} else o.metaData.mode !== "conversational" && (o.metaData.mode = "completion");
+	let f = a.maskedLoss ?? a.method.type === "supervised", p, m = l;
+	if (Array.isArray(c)) if (c[0] instanceof Uint16Array) p = c;
+	else {
+		let e = await t(c, s, {
+			masking: f,
+			validationSplit: a.validationSplit
+		});
+		p = e.trainingTokens, l || (m = e.validationTokens);
+	}
+	else p = c;
+	let h = p instanceof e ? p.getTokenCount() : p.reduce((e, t) => e + t.length, 0);
+	a.epochSteps = Math.ceil(h / ((a?.batchSize || 32) * o.config.blockSize));
+	let g = new n(s, o.config.blockSize);
+	if (m) {
+		let { trainDataset: e, validationDataset: t } = await r(p, m, s, g, a?.batchSize || 32);
+		return {
+			trainDataset: e,
+			validationDataset: t,
+			totalTokens: h
+		};
+	} else {
+		let t = p instanceof e ? p : await i(p, s);
+		return {
+			trainDataset: (await g.createTextDataset(t, a)).dataset,
+			validationDataset: void 0,
+			totalTokens: h
+		};
+	}
+}
+//#endregion
+export { a as default };

package/dist/training/tasks/tokenStream.d.ts

@@ -1,4 +1,5 @@
-import { ConversationStream, ITokeniser } from '../../../main';
+import { ITokeniser } from '../../../tokeniser/type';
+import { ConversationStream } from '../../../data/stream';
 import { TokenStore } from './TokenStore';
 interface TokensFromTasksOptions {
     masking?: boolean;

package/dist/training/types.d.ts

@@ -1,6 +1,9 @@
 import { TensorStatistics } from '../../checks/weights';
 import { LoRAConfig } from '../../models/config';
 import { NamedTensorMap, Tensor } from '@tensorflow/tfjs-core';
+import { TokenStore } from './tasks/TokenStore';
+import { ConversationStream } from '../../data/stream';
+import { DatasetMetadata } from '../../loader/types';
 export interface Metrics {
     accuracy?: number;
     perplexity?: number;
@@ -43,7 +46,13 @@ export interface AdamWOptimizerConfig extends LRSchedulerConfig {
     orthoGrad?: boolean;
 }
 export type TrainingMetrics = 'accuracy' | 'perplexity' | 'gradientNorm' | 'gradientStatistics' | 'weightNorm' | 'weightStatistics' | 'memoryUsage' | 'tokensPerSecond' | 'learningRate';
+export interface TrainingMethod {
+    type: 'pretraining' | 'supervised';
+    supervised?: 'full' | 'lora' | 'last-layer';
+}
 export interface TrainingOptions extends Partial<AdamWOptimizerConfig> {
+    previous_job_id?: string;
+    method: TrainingMethod;
     batchSize: number;
     maxEpochs?: number;
     logInterval?: number;
@@ -54,7 +63,6 @@ export interface TrainingOptions extends Partial<AdamWOptimizerConfig> {
     trainableWeights?: string[];
     loraConfig?: LoRAConfig;
     loraName?: string;
-    sftMode: 'full' | 'lora' | 'last-layer';
     maskedLoss?: boolean;
     metrics?: TrainingMetrics[];
     contextScaling?: number;
@@ -62,6 +70,11 @@ export interface TrainingOptions extends Partial<AdamWOptimizerConfig> {
     dropout?: number;
     layerDrop?: number;
     debug?: boolean;
+}
+export interface TrainingContext {
+    training_data: ConversationStream[] | Uint16Array[] | TokenStore;
+    validation_data?: Uint16Array[] | TokenStore;
+    datasets?: DatasetMetadata[];
     onStep?: (log: TrainingLogEntry) => void;
 }
 export interface TrainingState {

package/dist/training/validateOptions.d.ts

@@ -0,0 +1,2 @@
+import { TrainingOptions } from './types';
+export default function validateOptions(options: TrainingOptions, training: boolean, oldOptions?: TrainingOptions): TrainingOptions;

package/dist/training/validateOptions.js

@@ -0,0 +1,19 @@
+//#region lib/training/validateOptions.ts
+function e(e, t, n) {
+	let r = new Set(Object.keys(e).filter((t) => e[t] !== n?.[t]));
+	if (t) {
+		if (r.has("batchSize")) throw Error("Cannot change batch size during training");
+		if (r.has("sftMode")) throw Error("Cannot change SFT mode during training");
+		if (r.has("loraConfig")) throw Error("Cannot change LoRA configuration during training");
+		if (r.has("validationSplit")) throw Error("Cannot change validation split during training");
+		if (r.has("trainableWeights")) throw Error("Cannot change trainable weights during training");
+		if (r.has("mixedPrecision")) throw Error("Cannot change mixed precision setting during training");
+		if (r.has("gradientCheckpointing")) throw Error("Cannot change gradient checkpointing setting during training");
+	}
+	return {
+		...n,
+		...e
+	};
+}
+//#endregion
+export { e as default };

package/dist/utilities/arrayShape.d.ts

@@ -0,0 +1 @@
+export default function arrayShape(arr: unknown[]): number[];

package/dist/utilities/arrayShape.js

@@ -0,0 +1,8 @@
+//#region lib/utilities/arrayShape.ts
+function e(e) {
+	let t = [], n = e;
+	for (; Array.isArray(n);) t.push(n.length), n = n[n.length - 1];
+	return t;
+}
+//#endregion
+export { e as default };

package/dist/utilities/waitForModel.d.ts

@@ -1,2 +1,2 @@
-import { TeachableLLM } from '../../main';
+import { default as TeachableLLM } from '../../TeachableLLM';
 export default function waitForModel(model: TeachableLLM): Promise<void>;

package/dist/v4-BK7K-jy_.js

@@ -0,0 +1,30 @@
+//#region node_modules/uuid/dist/stringify.js
+var e = [];
+for (let t = 0; t < 256; ++t) e.push((t + 256).toString(16).slice(1));
+function t(t, n = 0) {
+	return (e[t[n + 0]] + e[t[n + 1]] + e[t[n + 2]] + e[t[n + 3]] + "-" + e[t[n + 4]] + e[t[n + 5]] + "-" + e[t[n + 6]] + e[t[n + 7]] + "-" + e[t[n + 8]] + e[t[n + 9]] + "-" + e[t[n + 10]] + e[t[n + 11]] + e[t[n + 12]] + e[t[n + 13]] + e[t[n + 14]] + e[t[n + 15]]).toLowerCase();
+}
+//#endregion
+//#region node_modules/uuid/dist/rng.js
+var n = new Uint8Array(16);
+function r() {
+	return crypto.getRandomValues(n);
+}
+//#endregion
+//#region node_modules/uuid/dist/v4.js
+function i(e, t, n) {
+	return !t && !e && crypto.randomUUID ? crypto.randomUUID() : a(e, t, n);
+}
+function a(e, n, i) {
+	e ||= {};
+	let a = e.random ?? e.rng?.() ?? r();
+	if (a.length < 16) throw Error("Random bytes length must be >= 16");
+	if (a[6] = a[6] & 15 | 64, a[8] = a[8] & 63 | 128, n) {
+		if (i ||= 0, i < 0 || i + 16 > n.length) throw RangeError(`UUID byte range ${i}:${i + 15} is out of buffer bounds`);
+		for (let e = 0; e < 16; ++e) n[i + e] = a[e];
+		return n;
+	}
+	return t(a);
+}
+//#endregion
+export { i as t };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@genai-fi/nanogpt",
-    "version": "0.24.0",
+    "version": "1.0.0",
     "type": "module",
     "main": "dist/main.js",
     "types": "dist/main.d.ts",
@@ -29,7 +29,7 @@
     "devDependencies": {
         "@eslint/js": "^10.0.1",
         "@playwright/test": "^1.55.0",
-        "@types/node": "^22.13.14",
+        "@types/node": "^26.2.0",
         "@types/papaparse": "^5.3.16",
         "@types/picomatch": "^4.0.2",
         "@types/yargs": "^17.0.33",
@@ -60,5 +60,11 @@
         "pdfjs-dist": "^5.4.149",
         "picomatch": "^4.0.3",
         "uuid": "^14.0.0"
+    },
+    "allowScripts": {
+        "webgpu@0.4.0": true,
+        "esbuild@0.28.1": true,
+        "core-js@3.29.1": true,
+        "patch-package@8.0.1": true
     }
 }

package/dist/Generator.js

@@ -1,2 +0,0 @@
-import { a as e, i as t } from "./main-Dz72vadm.js";
-export { t as default, e as isConversation };