@trymirai/uzu 0.3.1 → 0.4.0

package/src/bridging/model.ts

@@ -1,68 +0,0 @@
-import { Model as NapiModel } from '../napi/uzu';
-import { ClassificationLabel } from './classificationLabel';
-import { ModelKind, modelKindFromNapiModelKind, modelKindToNapiModelKind } from './modelKind';
-import { ModelType, modelTypeFromNapiModelType, modelTypeToNapiModelType } from './modelType';
-
-export class Model {
-    readonly repoId: string;
-    readonly type: ModelType;
-    readonly kind: ModelKind;
-    readonly name: string;
-    readonly vendor: string;
-    readonly quantization: string | null;
-    readonly outputParserRegex: string | null;
-    readonly classificationLabels: ClassificationLabel[];
-
-    get isThinking(): boolean {
-        return this.outputParserRegex !== null;
-    }
-
-    private constructor(
-        repoId: string,
-        type: ModelType,
-        kind: ModelKind,
-        name: string,
-        vendor: string,
-        quantization: string | null,
-        outputParserRegex: string | null,
-        classificationLabels: ClassificationLabel[],
-    ) {
-        this.repoId = repoId;
-        this.type = type;
-        this.kind = kind;
-        this.name = name;
-        this.vendor = vendor;
-        this.quantization = quantization;
-        this.outputParserRegex = outputParserRegex;
-        this.classificationLabels = classificationLabels;
-    }
-
-    static fromNapiModel(napiModel: NapiModel): Model {
-        return new Model(
-            napiModel.repoId,
-            modelTypeFromNapiModelType(napiModel.type),
-            modelKindFromNapiModelKind(napiModel.kind),
-            napiModel.name,
-            napiModel.vendor,
-            napiModel.quantization ?? null,
-            napiModel.outputParserRegex ?? null,
-            napiModel.classificationLabels.map(ClassificationLabel.fromNapi),
-        );
-    }
-
-    toNapi(): NapiModel {
-        const napiModel: NapiModel = {
-            repoId: this.repoId,
-            type: modelTypeToNapiModelType(this.type),
-            kind: modelKindToNapiModelKind(this.kind),
-            name: this.name,
-            vendor: this.vendor,
-            ...(this.quantization !== null && { quantization: this.quantization }),
-            ...(this.outputParserRegex !== null && { outputParserRegex: this.outputParserRegex }),
-            classificationLabels: this.classificationLabels.map((classificationLabel) =>
-                classificationLabel.toNapi(),
-            ),
-        };
-        return napiModel;
-    }
-}

package/src/bridging/modelKind.ts

@@ -1,27 +0,0 @@
-import { EngineError, EngineErrorCode } from '../error';
-import { ModelKind as NapiModelKind } from '../napi/uzu';
-
-export enum ModelKind {
-    Local = 'Local',
-    Cloud = 'Cloud',
-}
-
-export function modelKindFromNapiModelKind(napiModelKind: NapiModelKind): ModelKind {
-    switch (napiModelKind) {
-        case 0:
-            return ModelKind.Local;
-        case 1:
-            return ModelKind.Cloud;
-        default:
-            throw new EngineError(EngineErrorCode.UnexpectedModelKind);
-    }
-}
-
-export function modelKindToNapiModelKind(modelKind: ModelKind): NapiModelKind {
-    switch (modelKind) {
-        case ModelKind.Local:
-            return 0;
-        case ModelKind.Cloud:
-            return 1;
-    }
-}

package/src/bridging/modelType.ts

@@ -1,32 +0,0 @@
-import { EngineError, EngineErrorCode } from '../error';
-import { ModelType as NapiModelType } from '../napi/uzu';
-
-export enum ModelType {
-    Chat = 'Chat',
-    Classification = 'Classification',
-    TTS = 'TTS',
-}
-
-export function modelTypeFromNapiModelType(napiModelType: NapiModelType): ModelType {
-    switch (napiModelType) {
-        case 0:
-            return ModelType.Chat;
-        case 1:
-            return ModelType.Classification;
-        case 2:
-            return ModelType.TTS;
-        default:
-            throw new EngineError(EngineErrorCode.UnexpectedModelType);
-    }
-}
-
-export function modelTypeToNapiModelType(modelType: ModelType): NapiModelType {
-    switch (modelType) {
-        case ModelType.Chat:
-            return 0;
-        case ModelType.Classification:
-            return 1;
-        case ModelType.TTS:
-            return 2;
-    }
-}

package/src/bridging/napi.ts

@@ -1,3 +0,0 @@
-export interface ToNapi<N> {
-    toNapi(): N;
-}

package/src/bridging/output.ts

@@ -1,40 +0,0 @@
-import { EngineError, EngineErrorCode } from '../error';
-import { FinishReason as NapiFinishReason, Output as NapiOutput } from '../napi/uzu';
-import { FinishReason } from './finishReason';
-import { Stats } from './stats';
-import { Text } from './text';
-
-export class Output {
-    readonly text: Text;
-    readonly stats: Stats;
-    readonly finishReason: FinishReason | null;
-
-    private constructor(text: Text, stats: Stats, finishReason: FinishReason | null) {
-        this.text = text;
-        this.stats = stats;
-        this.finishReason = finishReason;
-    }
-
-    private static napiFinishReasonToFinishReason(napiFinishReason: NapiFinishReason): FinishReason {
-        switch (napiFinishReason) {
-            case 0:
-                return FinishReason.Stop;
-            case 1:
-                return FinishReason.Length;
-            case 2:
-                return FinishReason.Cancelled;
-            case 3:
-                return FinishReason.ContextLimitReached;
-            default:
-                throw new EngineError(EngineErrorCode.UnexpectedFinishReason);
-        }
-    }
-
-    static fromNapi(napiEntity: NapiOutput): Output {
-        const text = Text.fromNapi(napiEntity.text);
-        const stats = Stats.fromNapi(napiEntity.stats);
-        const finishReason =
-            napiEntity.finishReason ? Output.napiFinishReasonToFinishReason(napiEntity.finishReason) : null;
-        return new Output(text, stats, finishReason);
-    }
-}

package/src/bridging/parsedText.ts

@@ -1,27 +0,0 @@
-import * as z from 'zod';
-import { ParsedText as NapiParsedText } from '../napi/uzu';
-
-export class ParsedText {
-    readonly chainOfThought: string | null;
-    readonly response: string | null;
-
-    private constructor(chainOfThought: string | null, response: string | null) {
-        this.chainOfThought = chainOfThought;
-        this.response = response;
-    }
-
-    static fromNapi(napiEntity: NapiParsedText): ParsedText {
-        const chainOfThought = napiEntity.chainOfThought ?? null;
-        const response = napiEntity.response ?? null;
-        return new ParsedText(chainOfThought, response);
-    }
-
-    structuredResponse<T extends z.ZodType>(type: T): z.infer<T> | null {
-        if (this.response === null) {
-            return null;
-        }
-        const data = JSON.parse(this.response);
-        const result = type.parse(data);
-        return result;
-    }
-}

package/src/bridging/prefillStepSize.ts

@@ -1,32 +0,0 @@
-import { PrefillStepSize as NapiPrefillStepSize } from '../napi/uzu';
-import { ToNapi } from './napi';
-
-export class PrefillStepSize implements ToNapi<NapiPrefillStepSize> {
-    private readonly napiPrefillStepSize: NapiPrefillStepSize;
-
-    private constructor(napiPrefillStepSize: NapiPrefillStepSize) {
-        this.napiPrefillStepSize = napiPrefillStepSize;
-    }
-
-    static default(): PrefillStepSize {
-        const napiPrefillStepSize: NapiPrefillStepSize = { type: 'Default' };
-        return new PrefillStepSize(napiPrefillStepSize);
-    }
-
-    static maximal(): PrefillStepSize {
-        const napiPrefillStepSize: NapiPrefillStepSize = { type: 'Maximal' };
-        return new PrefillStepSize(napiPrefillStepSize);
-    }
-
-    static custom(length: number): PrefillStepSize {
-        const napiPrefillStepSize: NapiPrefillStepSize = {
-            type: 'Custom',
-            length,
-        };
-        return new PrefillStepSize(napiPrefillStepSize);
-    }
-
-    toNapi(): NapiPrefillStepSize {
-        return this.napiPrefillStepSize;
-    }
-}

package/src/bridging/preset.ts

@@ -1,48 +0,0 @@
-import { Preset as NapiPreset } from '../napi/uzu';
-import { ClassificationFeature } from './classificationFeature';
-import { ToNapi } from './napi';
-
-export class Preset implements ToNapi<NapiPreset> {
-    private readonly napiPreset: NapiPreset;
-
-    private constructor(napiPreset: NapiPreset) {
-        this.napiPreset = napiPreset;
-    }
-
-    static general(): Preset {
-        const napiPreset: NapiPreset = { type: 'General' };
-        return new Preset(napiPreset);
-    }
-
-    static classification(feature: ClassificationFeature): Preset {
-        const napiClassificationFeature = feature.toNapi();
-        const napiPreset: NapiPreset = {
-            type: 'Classification',
-            feature: napiClassificationFeature,
-        };
-        return new Preset(napiPreset);
-    }
-
-    static summarization(): Preset {
-        const napiPreset: NapiPreset = { type: 'Summarization' };
-        return new Preset(napiPreset);
-    }
-
-    static nGramSpeculator(useCase: string, numberOfSpeculatedTokens: number): Preset {
-        const napiPreset: NapiPreset = {
-            type: 'NGramSpeculator',
-            useCase,
-            numberOfSpeculatedTokens,
-        };
-        return new Preset(napiPreset);
-    }
-
-    static chat(): Preset {
-        const napiPreset: NapiPreset = { type: 'Chat' };
-        return new Preset(napiPreset);
-    }
-
-    toNapi(): NapiPreset {
-        return this.napiPreset;
-    }
-}

package/src/bridging/role.ts

@@ -1,5 +0,0 @@
-export enum Role {
-    System = 'system',
-    User = 'user',
-    Assistant = 'assistant',
-}

package/src/bridging/runConfig.ts

@@ -1,57 +0,0 @@
-import { RunConfig as NapiRunConfig } from '../napi/uzu';
-import { GrammarConfig } from './grammarConfig';
-import { ToNapi } from './napi';
-import { SamplingPolicy } from './samplingPolicy';
-
-export class RunConfig implements ToNapi<NapiRunConfig> {
-    readonly tokensLimit: number;
-    readonly enableThinking: boolean;
-    readonly samplingPolicy: SamplingPolicy;
-    readonly grammarConfig: GrammarConfig | null;
-
-    private constructor(
-        tokensLimit: number,
-        enableThinking: boolean,
-        samplingPolicy: SamplingPolicy,
-        grammarConfig: GrammarConfig | null,
-    ) {
-        this.tokensLimit = tokensLimit;
-        this.enableThinking = enableThinking;
-        this.samplingPolicy = samplingPolicy;
-        this.grammarConfig = grammarConfig;
-    }
-
-    static default(): RunConfig {
-        return new RunConfig(1024, true, SamplingPolicy.default(), null);
-    }
-
-    withTokensLimit(tokensLimit: number): RunConfig {
-        return new RunConfig(tokensLimit, this.enableThinking, this.samplingPolicy, this.grammarConfig);
-    }
-
-    withEnableThinking(enableThinking: boolean): RunConfig {
-        return new RunConfig(this.tokensLimit, enableThinking, this.samplingPolicy, this.grammarConfig);
-    }
-
-    withSamplingPolicy(samplingPolicy: SamplingPolicy): RunConfig {
-        return new RunConfig(this.tokensLimit, this.enableThinking, samplingPolicy, this.grammarConfig);
-    }
-
-    withGrammarConfig(grammarConfig: GrammarConfig | null): RunConfig {
-        return new RunConfig(this.tokensLimit, this.enableThinking, this.samplingPolicy, grammarConfig);
-    }
-
-    toNapi(): NapiRunConfig {
-        const napiSamplingPolicy = this.samplingPolicy.toNapi();
-        let napiRunConfig: NapiRunConfig = {
-            tokensLimit: this.tokensLimit,
-            enableThinking: this.enableThinking,
-            samplingPolicy: napiSamplingPolicy,
-        };
-        if (this.grammarConfig !== null) {
-            let napiGrammarConfig = this.grammarConfig.toNapi();
-            napiRunConfig.grammarConfig = napiGrammarConfig;
-        }
-        return napiRunConfig;
-    }
-}

package/src/bridging/runStats.ts

@@ -1,17 +0,0 @@
-import { RunStats as NapiRunStats } from '../napi/uzu';
-
-export class RunStats {
-    readonly count: number;
-    readonly averageDuration: number;
-
-    private constructor(count: number, averageDuration: number) {
-        this.count = count;
-        this.averageDuration = averageDuration;
-    }
-
-    static fromNapi(napiEntity: NapiRunStats): RunStats {
-        const count = Number(napiEntity.count);
-        const averageDuration = napiEntity.averageDuration;
-        return new RunStats(count, averageDuration);
-    }
-}

package/src/bridging/samplingMethod.ts

@@ -1,49 +0,0 @@
-import { SamplingMethod as NapiSamplingMethod } from '../napi/uzu';
-import { ToNapi } from './napi';
-import {
-    SamplingProcessingOrder,
-    samplingProcessingOrderToNapiSamplingProcessingOrder,
-} from './samplingProcessingOrder';
-
-export class SamplingMethod implements ToNapi<NapiSamplingMethod> {
-    private readonly napiSamplingMethod: NapiSamplingMethod;
-
-    private constructor(napiSamplingMethod: NapiSamplingMethod) {
-        this.napiSamplingMethod = napiSamplingMethod;
-    }
-
-    static greedy(): SamplingMethod {
-        const napiSamplingMethod: NapiSamplingMethod = { type: 'Greedy' };
-        return new SamplingMethod(napiSamplingMethod);
-    }
-
-    static stochastic(
-        temperature: number | null,
-        topK: number | null,
-        topP: number | null,
-        minP: number | null,
-        processingOrder: SamplingProcessingOrder,
-    ): SamplingMethod {
-        let napiSamplingMethod: NapiSamplingMethod = {
-            type: 'Stochastic',
-            processingOrder: samplingProcessingOrderToNapiSamplingProcessingOrder(processingOrder),
-        };
-        if (temperature !== null) {
-            napiSamplingMethod.temperature = temperature;
-        }
-        if (topK !== null) {
-            napiSamplingMethod.topK = topK;
-        }
-        if (topP !== null) {
-            napiSamplingMethod.topP = topP;
-        }
-        if (minP !== null) {
-            napiSamplingMethod.minP = minP;
-        }
-        return new SamplingMethod(napiSamplingMethod);
-    }
-
-    toNapi(): NapiSamplingMethod {
-        return this.napiSamplingMethod;
-    }
-}

package/src/bridging/samplingPolicy.ts

@@ -1,29 +0,0 @@
-import { SamplingPolicy as NapiSamplingPolicy } from '../napi/uzu';
-import { ToNapi } from './napi';
-import { SamplingMethod } from './samplingMethod';
-
-export class SamplingPolicy implements ToNapi<NapiSamplingPolicy> {
-    private readonly napiSamplingPolicy: NapiSamplingPolicy;
-
-    private constructor(napiSamplingPolicy: NapiSamplingPolicy) {
-        this.napiSamplingPolicy = napiSamplingPolicy;
-    }
-
-    static default(): SamplingPolicy {
-        const napiSamplingPolicy: NapiSamplingPolicy = { type: 'Default' };
-        return new SamplingPolicy(napiSamplingPolicy);
-    }
-
-    static custom(method: SamplingMethod): SamplingPolicy {
-        const napiSamplingMethod = method.toNapi();
-        const napiSamplingPolicy: NapiSamplingPolicy = {
-            type: 'Custom',
-            value: napiSamplingMethod,
-        };
-        return new SamplingPolicy(napiSamplingPolicy);
-    }
-
-    toNapi(): NapiSamplingPolicy {
-        return this.napiSamplingPolicy;
-    }
-}

package/src/bridging/samplingProcessingOrder.ts

@@ -1,31 +0,0 @@
-import { EngineError, EngineErrorCode } from '../error';
-import { SamplingProcessingOrder as NapiSamplingProcessingOrder } from '../napi/uzu';
-
-export enum SamplingProcessingOrder {
-    TemperatureThenFilters = 'TemperatureThenFilters',
-    FiltersThenTemperature = 'FiltersThenTemperature',
-}
-
-export function samplingProcessingOrderFromNapiSamplingProcessingOrder(
-    napiSamplingProcessingOrder: NapiSamplingProcessingOrder,
-): SamplingProcessingOrder {
-    switch (napiSamplingProcessingOrder) {
-        case 0:
-            return SamplingProcessingOrder.TemperatureThenFilters;
-        case 1:
-            return SamplingProcessingOrder.FiltersThenTemperature;
-        default:
-            throw new EngineError(EngineErrorCode.UnexpectedSamplingProcessingOrder);
-    }
-}
-
-export function samplingProcessingOrderToNapiSamplingProcessingOrder(
-    samplingProcessingOrder: SamplingProcessingOrder,
-): NapiSamplingProcessingOrder {
-    switch (samplingProcessingOrder) {
-        case SamplingProcessingOrder.TemperatureThenFilters:
-            return 0;
-        case SamplingProcessingOrder.FiltersThenTemperature:
-            return 1;
-    }
-}

package/src/bridging/samplingSeed.ts

@@ -1,24 +0,0 @@
-import { SamplingSeed as NapiSamplingSeed } from '../napi/uzu';
-import { ToNapi } from './napi';
-
-export class SamplingSeed implements ToNapi<NapiSamplingSeed> {
-    private readonly napiSamplingSeed: NapiSamplingSeed;
-
-    private constructor(napiSamplingSeed: NapiSamplingSeed) {
-        this.napiSamplingSeed = napiSamplingSeed;
-    }
-
-    static default(): SamplingSeed {
-        const napiSamplingSeed: NapiSamplingSeed = { type: 'Default' };
-        return new SamplingSeed(napiSamplingSeed);
-    }
-
-    static custom(seed: number): SamplingSeed {
-        const napiSamplingSeed: NapiSamplingSeed = { type: 'Custom', seed };
-        return new SamplingSeed(napiSamplingSeed);
-    }
-
-    toNapi(): NapiSamplingSeed {
-        return this.napiSamplingSeed;
-    }
-}

package/src/bridging/stats.ts

@@ -1,22 +0,0 @@
-import { Stats as NapiStats } from '../napi/uzu';
-import { StepStats } from './stepStats';
-import { TotalStats } from './totalStats';
-
-export class Stats {
-    readonly prefillStats: StepStats;
-    readonly generateStats: StepStats | null;
-    readonly totalStats: TotalStats;
-
-    private constructor(prefillStats: StepStats, generateStats: StepStats | null, totalStats: TotalStats) {
-        this.prefillStats = prefillStats;
-        this.generateStats = generateStats;
-        this.totalStats = totalStats;
-    }
-
-    static fromNapi(napiEntity: NapiStats): Stats {
-        const prefillStats = StepStats.fromNapi(napiEntity.prefillStats);
-        const generateStats = napiEntity.generateStats ? StepStats.fromNapi(napiEntity.generateStats) : null;
-        const totalStats = TotalStats.fromNapi(napiEntity.totalStats);
-        return new Stats(prefillStats, generateStats, totalStats);
-    }
-}

package/src/bridging/stepStats.ts

@@ -1,49 +0,0 @@
-import { StepStats as NapiStepStats } from '../napi/uzu';
-import { RunStats } from './runStats';
-
-export class StepStats {
-    readonly duration: number;
-    readonly suffixLength: number;
-    readonly tokensCount: number;
-    readonly tokensPerSecond: number;
-    readonly processedTokensPerSecond: number;
-    readonly modelRun: RunStats;
-    readonly run: RunStats | null;
-
-    private constructor(
-        duration: number,
-        suffixLength: number,
-        tokensCount: number,
-        tokensPerSecond: number,
-        processedTokensPerSecond: number,
-        modelRun: RunStats,
-        run: RunStats | null,
-    ) {
-        this.duration = duration;
-        this.suffixLength = suffixLength;
-        this.tokensCount = tokensCount;
-        this.tokensPerSecond = tokensPerSecond;
-        this.processedTokensPerSecond = processedTokensPerSecond;
-        this.modelRun = modelRun;
-        this.run = run;
-    }
-
-    static fromNapi(napiEntity: NapiStepStats): StepStats {
-        const duration = napiEntity.duration;
-        const suffixLength = Number(napiEntity.suffixLength);
-        const tokensCount = Number(napiEntity.tokensCount);
-        const tokensPerSecond = napiEntity.tokensPerSecond;
-        const processedTokensPerSecond = napiEntity.processedTokensPerSecond;
-        const modelRun = RunStats.fromNapi(napiEntity.modelRun);
-        const run = napiEntity.run ? RunStats.fromNapi(napiEntity.run) : null;
-        return new StepStats(
-            duration,
-            suffixLength,
-            tokensCount,
-            tokensPerSecond,
-            processedTokensPerSecond,
-            modelRun,
-            run,
-        );
-    }
-}

package/src/bridging/text.ts

@@ -1,18 +0,0 @@
-import { Text as NapiText } from '../napi/uzu';
-import { ParsedText } from './parsedText';
-
-export class Text {
-    readonly original: string;
-    readonly parsed: ParsedText;
-
-    private constructor(original: string, parsed: ParsedText) {
-        this.original = original;
-        this.parsed = parsed;
-    }
-
-    static fromNapi(napiEntity: NapiText): Text {
-        const original = napiEntity.original;
-        const parsed = ParsedText.fromNapi(napiEntity.parsed);
-        return new Text(original, parsed);
-    }
-}

package/src/bridging/textToSpeechSession.ts

@@ -1,15 +0,0 @@
-import { TextToSpeechSession as NapiTextToSpeechSession } from '../napi/uzu';
-import { Input } from './input';
-
-export class TextToSpeechSession {
-    private readonly napiTextToSpeechSession: NapiTextToSpeechSession;
-
-    constructor(napiTextToSpeechSession: NapiTextToSpeechSession) {
-        this.napiTextToSpeechSession = napiTextToSpeechSession;
-    }
-
-    run(input: Input, outputPath: string): void {
-        const napiInput = input.toNapi();
-        this.napiTextToSpeechSession.run(napiInput, outputPath);
-    }
-}

package/src/bridging/totalStats.ts

@@ -1,20 +0,0 @@
-import { TotalStats as NapiTotalStats } from '../napi/uzu';
-
-export class TotalStats {
-    readonly duration: number;
-    readonly tokensCountInput: number;
-    readonly tokensCountOutput: number;
-
-    private constructor(duration: number, tokensCountInput: number, tokensCountOutput: number) {
-        this.duration = duration;
-        this.tokensCountInput = tokensCountInput;
-        this.tokensCountOutput = tokensCountOutput;
-    }
-
-    static fromNapi(napiEntity: NapiTotalStats): TotalStats {
-        const duration = napiEntity.duration;
-        const tokensCountInput = Number(napiEntity.tokensCountInput);
-        const tokensCountOutput = Number(napiEntity.tokensCountOutput);
-        return new TotalStats(duration, tokensCountInput, tokensCountOutput);
-    }
-}

package/src/error.ts

@@ -1,42 +0,0 @@
-export enum EngineErrorCode {
-    APIKeyNotFound = 'apiKeyNotFound',
-    ModelNotFound = 'modelNotFound',
-    ExpectedLocalModel = 'expectedLocalModel',
-    UnexpectedDownloadPhase = 'unexpectedDownloadPhase',
-    UnexpectedFinishReason = 'unexpectedFinishReason',
-    UnexpectedLicenseStatus = 'unexpectedLicenseStatus',
-    UnexpectedModelType = 'unexpectedModelType',
-    UnexpectedModelKind = 'unexpectedModelKind',
-    UnexpectedSamplingProcessingOrder = 'unexpectedSamplingProcessingOrder',
-    LicenseNotActivated = 'licenseNotActivated',
-    Unknown = 'unknown',
-}
-
-const errorCodeToMessage = {
-    [EngineErrorCode.APIKeyNotFound]: 'API key not found',
-    [EngineErrorCode.ModelNotFound]: 'Model not found',
-    [EngineErrorCode.ExpectedLocalModel]: 'Expected local model',
-    [EngineErrorCode.UnexpectedDownloadPhase]: 'Unexpected download phase',
-    [EngineErrorCode.UnexpectedFinishReason]: 'Unexpected finish reason',
-    [EngineErrorCode.UnexpectedLicenseStatus]: 'Unexpected license status',
-    [EngineErrorCode.UnexpectedModelType]: 'Unexpected model type',
-    [EngineErrorCode.UnexpectedModelKind]: 'Unexpected model kind',
-    [EngineErrorCode.UnexpectedSamplingProcessingOrder]: 'Unexpected sampling processing order',
-    [EngineErrorCode.LicenseNotActivated]: 'License not activated',
-    [EngineErrorCode.Unknown]: 'Unknown error',
-};
-
-export class EngineError extends Error {
-    constructor(code: EngineErrorCode) {
-        const message = errorCodeToMessage[code] ?? errorCodeToMessage[EngineErrorCode.Unknown];
-        super(message);
-        this.name = 'EngineError';
-    }
-}
-
-export function unwrapOrThrow<T>(value: T | null | undefined, errorCode: EngineErrorCode): T {
-    if (value === null || value === undefined) {
-        throw new EngineError(errorCode);
-    }
-    return value;
-}