modelfusion 0.0.44

package/run/DefaultRun.cjs

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultRun = void 0;
+const nanoid_1 = require("nanoid");
+const SuccessfulModelCall_js_1 = require("../model-function/SuccessfulModelCall.cjs");
+const calculateCost_js_1 = require("../cost/calculateCost.cjs");
+class DefaultRun {
+    constructor({ runId = (0, nanoid_1.nanoid)(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
+        Object.defineProperty(this, "runId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "abortSignal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "costCalculators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelCallEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "observers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.runId = runId;
+        this.sessionId = sessionId;
+        this.userId = userId;
+        this.abortSignal = abortSignal;
+        this.costCalculators = costCalculators;
+        this.observers = [
+            {
+                onModelCallStarted: (event) => {
+                    this.modelCallEvents.push(event);
+                },
+                onModelCallFinished: (event) => {
+                    this.modelCallEvents.push(event);
+                },
+            },
+            ...(observers ?? []),
+        ];
+    }
+    get successfulModelCalls() {
+        return (0, SuccessfulModelCall_js_1.extractSuccessfulModelCalls)(this.modelCallEvents);
+    }
+    calculateCost() {
+        return (0, calculateCost_js_1.calculateCost)({
+            calls: this.successfulModelCalls,
+            costCalculators: this.costCalculators,
+        });
+    }
+}
+exports.DefaultRun = DefaultRun;

package/run/DefaultRun.d.ts

@@ -0,0 +1,24 @@
+import { SuccessfulModelCall } from "../model-function/SuccessfulModelCall.js";
+import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
+import { ModelCallObserver } from "../model-function/ModelCallObserver.js";
+import { Run } from "./Run.js";
+import { CostCalculator } from "../cost/CostCalculator.js";
+export declare class DefaultRun implements Run {
+    readonly runId: string;
+    readonly sessionId?: string;
+    readonly userId?: string;
+    readonly abortSignal?: AbortSignal;
+    readonly costCalculators: CostCalculator[];
+    readonly modelCallEvents: (ModelCallFinishedEvent | ModelCallStartedEvent)[];
+    readonly observers?: ModelCallObserver[];
+    constructor({ runId, sessionId, userId, abortSignal, observers, costCalculators, }?: {
+        runId?: string;
+        sessionId?: string;
+        userId?: string;
+        abortSignal?: AbortSignal;
+        observers?: ModelCallObserver[];
+        costCalculators?: CostCalculator[];
+    });
+    get successfulModelCalls(): Array<SuccessfulModelCall>;
+    calculateCost(): Promise<import("../index.js").Cost>;
+}

package/run/DefaultRun.js

@@ -0,0 +1,74 @@
+import { nanoid as createId } from "nanoid";
+import { extractSuccessfulModelCalls, } from "../model-function/SuccessfulModelCall.js";
+import { calculateCost } from "../cost/calculateCost.js";
+export class DefaultRun {
+    constructor({ runId = createId(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
+        Object.defineProperty(this, "runId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "abortSignal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "costCalculators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelCallEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "observers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.runId = runId;
+        this.sessionId = sessionId;
+        this.userId = userId;
+        this.abortSignal = abortSignal;
+        this.costCalculators = costCalculators;
+        this.observers = [
+            {
+                onModelCallStarted: (event) => {
+                    this.modelCallEvents.push(event);
+                },
+                onModelCallFinished: (event) => {
+                    this.modelCallEvents.push(event);
+                },
+            },
+            ...(observers ?? []),
+        ];
+    }
+    get successfulModelCalls() {
+        return extractSuccessfulModelCalls(this.modelCallEvents);
+    }
+    calculateCost() {
+        return calculateCost({
+            calls: this.successfulModelCalls,
+            costCalculators: this.costCalculators,
+        });
+    }
+}

package/run/IdMetadata.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/run/IdMetadata.d.ts

@@ -0,0 +1,7 @@
+export type IdMetadata = {
+    callId?: string | undefined;
+    functionId?: string | undefined;
+    runId?: string | undefined;
+    sessionId?: string | undefined;
+    userId?: string | undefined;
+};

package/run/IdMetadata.js

@@ -0,0 +1 @@
+export {};

package/run/Run.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/run/Run.d.ts

@@ -0,0 +1,27 @@
+import { ErrorHandler } from "../util/ErrorHandler.js";
+import { ModelCallObserver } from "../model-function/ModelCallObserver.js";
+export interface Run {
+    /**
+     * Unique identifier for a specific run. Primarily utilized for efficient referencing
+     * and tracking within logs.
+     */
+    runId?: string;
+    /**
+     * Unique identifier for a session. A session can contain multiple runs. For example, in
+     * a chatbot where each message is processed as a separate run, all those runs could be
+     * part of a single session. Useful for tracking and logging.
+     */
+    sessionId?: string;
+    /**
+     * The user ID of the individual who initiates the call. Useful for logging and can be
+     * configured to be forwarded to the model provider (like OpenAI).
+     */
+    userId?: string;
+    /**
+     * An AbortSignal that can be used to cancel any ongoing asynchronous operations tied
+     * to the run.
+     */
+    abortSignal?: AbortSignal;
+    observers?: ModelCallObserver[];
+    errorHandler?: ErrorHandler;
+}

package/run/Run.js

@@ -0,0 +1 @@
+export {};

package/run/RunFunction.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/run/RunFunction.d.ts

@@ -0,0 +1,13 @@
+import { SafeResult } from "../util/SafeResult.js";
+import { Run } from "./Run.js";
+/**
+ * Standardized function signature for functions that are part of a run.
+ *
+ * This enables wrapping and chaining of run functions.
+ */
+export type RunFunction<INPUT, OUTPUT> = (input: INPUT, options?: {
+    run?: Run;
+}) => PromiseLike<OUTPUT>;
+export type SafeRunFunction<INPUT, OUTPUT> = (input: INPUT, options?: {
+    run?: Run;
+}) => PromiseLike<SafeResult<OUTPUT>>;

package/run/RunFunction.js

@@ -0,0 +1 @@
+export {};

package/run/Vector.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/run/Vector.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A vector is an array of numbers.
+ * It is e.g. used to represent a text as a vector of word embeddings.
+ */
+export type Vector = Array<number>;

package/run/Vector.js

@@ -0,0 +1 @@
+export {};

package/run/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ConsoleLogger.cjs"), exports);
+__exportStar(require("./DefaultRun.cjs"), exports);
+__exportStar(require("./IdMetadata.cjs"), exports);
+__exportStar(require("./Run.cjs"), exports);
+__exportStar(require("./RunFunction.cjs"), exports);
+__exportStar(require("./Vector.cjs"), exports);

package/run/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./ConsoleLogger.js";
+export * from "./DefaultRun.js";
+export * from "./IdMetadata.js";
+export * from "./Run.js";
+export * from "./RunFunction.js";
+export * from "./Vector.js";

package/run/index.js

@@ -0,0 +1,6 @@
+export * from "./ConsoleLogger.js";
+export * from "./DefaultRun.js";
+export * from "./IdMetadata.js";
+export * from "./Run.js";
+export * from "./RunFunction.js";
+export * from "./Vector.js";

package/text-chunk/TextChunk.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/text-chunk/TextChunk.d.ts

@@ -0,0 +1,3 @@
+export type TextChunk = {
+    content: string;
+};

package/text-chunk/TextChunk.js

@@ -0,0 +1 @@
+export {};

package/text-chunk/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TextChunk.cjs"), exports);
+__exportStar(require("./retrieve-text-chunks/TextChunkRetriever.cjs"), exports);
+__exportStar(require("./retrieve-text-chunks/retrieveTextChunks.cjs"), exports);
+__exportStar(require("./split/SplitFunction.cjs"), exports);
+__exportStar(require("./split/splitOnSeparator.cjs"), exports);
+__exportStar(require("./split/splitRecursively.cjs"), exports);

package/text-chunk/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./TextChunk.js";
+export * from "./retrieve-text-chunks/TextChunkRetriever.js";
+export * from "./retrieve-text-chunks/retrieveTextChunks.js";
+export * from "./split/SplitFunction.js";
+export * from "./split/splitOnSeparator.js";
+export * from "./split/splitRecursively.js";

package/text-chunk/index.js

@@ -0,0 +1,6 @@
+export * from "./TextChunk.js";
+export * from "./retrieve-text-chunks/TextChunkRetriever.js";
+export * from "./retrieve-text-chunks/retrieveTextChunks.js";
+export * from "./split/SplitFunction.js";
+export * from "./split/splitOnSeparator.js";
+export * from "./split/splitRecursively.js";

package/text-chunk/retrieve-text-chunks/TextChunkRetriever.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/text-chunk/retrieve-text-chunks/TextChunkRetriever.d.ts

@@ -0,0 +1,8 @@
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { TextChunk } from "../TextChunk.js";
+export interface TextChunkRetrieverSettings {
+}
+export interface TextChunkRetriever<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings> {
+    retrieveTextChunks(query: QUERY, options?: FunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
+    withSettings(additionalSettings: Partial<SETTINGS>): this;
+}

package/text-chunk/retrieve-text-chunks/TextChunkRetriever.js

@@ -0,0 +1 @@
+export {};

package/text-chunk/retrieve-text-chunks/retrieveTextChunks.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveTextChunks = void 0;
+async function retrieveTextChunks(retriever, query, options) {
+    // TODO add error handling, events, duration tracking, etc.
+    return {
+        chunks: await retriever.retrieveTextChunks(query, options),
+    };
+}
+exports.retrieveTextChunks = retrieveTextChunks;

package/text-chunk/retrieve-text-chunks/retrieveTextChunks.d.ts

@@ -0,0 +1,6 @@
+import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { TextChunk } from "../TextChunk.js";
+import { TextChunkRetriever, TextChunkRetrieverSettings } from "./TextChunkRetriever.js";
+export declare function retrieveTextChunks<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings>(retriever: TextChunkRetriever<CHUNK, QUERY, SETTINGS>, query: QUERY, options?: FunctionOptions<SETTINGS>): Promise<{
+    chunks: CHUNK[];
+}>;

package/text-chunk/retrieve-text-chunks/retrieveTextChunks.js

@@ -0,0 +1,6 @@
+export async function retrieveTextChunks(retriever, query, options) {
+    // TODO add error handling, events, duration tracking, etc.
+    return {
+        chunks: await retriever.retrieveTextChunks(query, options),
+    };
+}

package/text-chunk/split/SplitFunction.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/text-chunk/split/SplitFunction.d.ts

@@ -0,0 +1,4 @@
+import { RunFunction } from "../../run/RunFunction.js";
+export type SplitFunction = RunFunction<{
+    text: string;
+}, Array<string>>;

package/text-chunk/split/SplitFunction.js

@@ -0,0 +1 @@
+export {};

package/text-chunk/split/splitOnSeparator.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitOnSeparatorAsSplitFunction = exports.splitOnSeparator = void 0;
+const splitOnSeparator = async ({ separator, text, }) => {
+    return text.split(separator);
+};
+exports.splitOnSeparator = splitOnSeparator;
+const splitOnSeparatorAsSplitFunction = ({ separator }) => async ({ text }) => (0, exports.splitOnSeparator)({
+    separator,
+    text,
+});
+exports.splitOnSeparatorAsSplitFunction = splitOnSeparatorAsSplitFunction;

package/text-chunk/split/splitOnSeparator.d.ts

@@ -0,0 +1,8 @@
+import { SplitFunction } from "./SplitFunction.js";
+export declare const splitOnSeparator: ({ separator, text, }: {
+    separator: string;
+    text: string;
+}) => Promise<string[]>;
+export declare const splitOnSeparatorAsSplitFunction: ({ separator }: {
+    separator: string;
+}) => SplitFunction;

package/text-chunk/split/splitOnSeparator.js

@@ -0,0 +1,7 @@
+export const splitOnSeparator = async ({ separator, text, }) => {
+    return text.split(separator);
+};
+export const splitOnSeparatorAsSplitFunction = ({ separator }) => async ({ text }) => splitOnSeparator({
+    separator,
+    text,
+});

package/text-chunk/split/splitRecursively.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitRecursivelyAtTokenAsSplitFunction = exports.splitRecursivelyAtToken = exports.splitRecursivelyAtCharacterAsSplitFunction = exports.splitRecursivelyAtCharacter = exports.splitRecursively = void 0;
+// when segments is a string, it splits by character, otherwise according to the provided segments
+function splitRecursively({ maxChunkSize, segments, }) {
+    if (segments.length < maxChunkSize) {
+        return Array.isArray(segments) ? [segments.join("")] : [segments];
+    }
+    const half = Math.ceil(segments.length / 2);
+    const left = segments.slice(0, half);
+    const right = segments.slice(half);
+    return [
+        ...splitRecursively({
+            segments: left,
+            maxChunkSize,
+        }),
+        ...splitRecursively({
+            segments: right,
+            maxChunkSize,
+        }),
+    ];
+}
+exports.splitRecursively = splitRecursively;
+const splitRecursivelyAtCharacter = async ({ maxChunkSize, text, }) => splitRecursively({
+    maxChunkSize,
+    segments: text,
+});
+exports.splitRecursivelyAtCharacter = splitRecursivelyAtCharacter;
+const splitRecursivelyAtCharacterAsSplitFunction = ({ maxChunkSize }) => async ({ text }) => (0, exports.splitRecursivelyAtCharacter)({ maxChunkSize, text });
+exports.splitRecursivelyAtCharacterAsSplitFunction = splitRecursivelyAtCharacterAsSplitFunction;
+const splitRecursivelyAtToken = async ({ tokenizer, maxChunkSize, text, }) => splitRecursively({
+    maxChunkSize,
+    segments: (await tokenizer.tokenizeWithTexts(text)).tokenTexts,
+});
+exports.splitRecursivelyAtToken = splitRecursivelyAtToken;
+const splitRecursivelyAtTokenAsSplitFunction = ({ tokenizer, maxChunkSize, }) => async ({ text }) => (0, exports.splitRecursivelyAtToken)({
+    tokenizer,
+    maxChunkSize,
+    text,
+});
+exports.splitRecursivelyAtTokenAsSplitFunction = splitRecursivelyAtTokenAsSplitFunction;

package/text-chunk/split/splitRecursively.d.ts

@@ -0,0 +1,22 @@
+import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
+import { SplitFunction } from "./SplitFunction.js";
+export declare function splitRecursively({ maxChunkSize, segments, }: {
+    maxChunkSize: number;
+    segments: string | Array<string>;
+}): Array<string>;
+export declare const splitRecursivelyAtCharacter: ({ maxChunkSize, text, }: {
+    maxChunkSize: number;
+    text: string;
+}) => Promise<string[]>;
+export declare const splitRecursivelyAtCharacterAsSplitFunction: ({ maxChunkSize }: {
+    maxChunkSize: number;
+}) => SplitFunction;
+export declare const splitRecursivelyAtToken: ({ tokenizer, maxChunkSize, text, }: {
+    tokenizer: FullTokenizer;
+    maxChunkSize: number;
+    text: string;
+}) => Promise<string[]>;
+export declare const splitRecursivelyAtTokenAsSplitFunction: ({ tokenizer, maxChunkSize, }: {
+    tokenizer: FullTokenizer;
+    maxChunkSize: number;
+}) => SplitFunction;

package/text-chunk/split/splitRecursively.js

@@ -0,0 +1,33 @@
+// when segments is a string, it splits by character, otherwise according to the provided segments
+export function splitRecursively({ maxChunkSize, segments, }) {
+    if (segments.length < maxChunkSize) {
+        return Array.isArray(segments) ? [segments.join("")] : [segments];
+    }
+    const half = Math.ceil(segments.length / 2);
+    const left = segments.slice(0, half);
+    const right = segments.slice(half);
+    return [
+        ...splitRecursively({
+            segments: left,
+            maxChunkSize,
+        }),
+        ...splitRecursively({
+            segments: right,
+            maxChunkSize,
+        }),
+    ];
+}
+export const splitRecursivelyAtCharacter = async ({ maxChunkSize, text, }) => splitRecursively({
+    maxChunkSize,
+    segments: text,
+});
+export const splitRecursivelyAtCharacterAsSplitFunction = ({ maxChunkSize }) => async ({ text }) => splitRecursivelyAtCharacter({ maxChunkSize, text });
+export const splitRecursivelyAtToken = async ({ tokenizer, maxChunkSize, text, }) => splitRecursively({
+    maxChunkSize,
+    segments: (await tokenizer.tokenizeWithTexts(text)).tokenTexts,
+});
+export const splitRecursivelyAtTokenAsSplitFunction = ({ tokenizer, maxChunkSize, }) => async ({ text }) => splitRecursivelyAtToken({
+    tokenizer,
+    maxChunkSize,
+    text,
+});

package/util/DurationMeasurement.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDurationMeasurement = void 0;
+function startDurationMeasurement() {
+    // certain environments may not have the performance API:
+    return globalThis.performance != null
+        ? new PerformanceNowDurationMeasurement()
+        : new DateDurationMeasurement();
+}
+exports.startDurationMeasurement = startDurationMeasurement;
+class PerformanceNowDurationMeasurement {
+    constructor() {
+        Object.defineProperty(this, "startTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: globalThis.performance.now()
+        });
+    }
+    get startEpochSeconds() {
+        return Math.floor((globalThis.performance.timeOrigin + this.startTime) / 1000);
+    }
+    get durationInMs() {
+        return Math.ceil(globalThis.performance.now() - this.startTime);
+    }
+}
+class DateDurationMeasurement {
+    constructor() {
+        Object.defineProperty(this, "startTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: Date.now()
+        });
+    }
+    get startEpochSeconds() {
+        return Math.floor(this.startTime / 1000);
+    }
+    get durationInMs() {
+        return Date.now() - this.startTime;
+    }
+}

package/util/DurationMeasurement.d.ts

@@ -0,0 +1,5 @@
+export declare function startDurationMeasurement(): DurationMeasurement;
+export interface DurationMeasurement {
+    startEpochSeconds: number;
+    durationInMs: number;
+}

package/util/DurationMeasurement.js

@@ -0,0 +1,38 @@
+export function startDurationMeasurement() {
+    // certain environments may not have the performance API:
+    return globalThis.performance != null
+        ? new PerformanceNowDurationMeasurement()
+        : new DateDurationMeasurement();
+}
+class PerformanceNowDurationMeasurement {
+    constructor() {
+        Object.defineProperty(this, "startTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: globalThis.performance.now()
+        });
+    }
+    get startEpochSeconds() {
+        return Math.floor((globalThis.performance.timeOrigin + this.startTime) / 1000);
+    }
+    get durationInMs() {
+        return Math.ceil(globalThis.performance.now() - this.startTime);
+    }
+}
+class DateDurationMeasurement {
+    constructor() {
+        Object.defineProperty(this, "startTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: Date.now()
+        });
+    }
+    get startEpochSeconds() {
+        return Math.floor(this.startTime / 1000);
+    }
+    get durationInMs() {
+        return Date.now() - this.startTime;
+    }
+}

package/util/ErrorHandler.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/util/ErrorHandler.d.ts

@@ -0,0 +1 @@
+export type ErrorHandler = (error: unknown) => void;

package/util/ErrorHandler.js

@@ -0,0 +1 @@
+export {};

package/util/SafeResult.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });