@jondotsoy/pika 0.1.1

package/lib/esm/flow/index.d.ts

@@ -0,0 +1,26 @@
+import { Job } from "./dto/job.js";
+import { z } from "zod";
+type Def = z.ZodTypeAny;
+type InferPayload<T extends Record<string, Def>> = {
+    [K in keyof T]: T[K] extends z.ZodType<any> ? z.infer<T[K]> : never;
+};
+export type CredentialDef = {
+    name: string;
+};
+export declare function credential(name: string): CredentialDef;
+type AppOptions<T extends Record<string, Def>> = {
+    input: T;
+    credentials?: CredentialDef[];
+    maxRetries?: number;
+    handler: (params: InferPayload<T>, jobCtx: Job) => Promise<any>;
+};
+export declare function app(appName: string, cb: (params: {}, jobCtx: Job) => Promise<any>): (jobId: string, options?: {
+    maxRetries?: number;
+}) => Job | undefined;
+export declare function app<T extends Record<string, Def>>(appName: string, input: T, cb: (params: InferPayload<T>, jobCtx: Job) => Promise<any>): (jobId: string, params: InferPayload<T>, options?: {
+    maxRetries?: number;
+}) => Job | undefined;
+export declare function app<T extends Record<string, Def>>(appName: string, options: AppOptions<T>): (jobId: string, params: InferPayload<T>, options?: {
+    maxRetries?: number;
+}) => Job | undefined;
+export {};

package/lib/esm/flow/index.js

@@ -0,0 +1,46 @@
+import { currentContext } from "./current.js";
+import { processingJobContext } from "./worker_ctx.js";
+import { z } from "zod";
+export function credential(name) {
+    return { name };
+}
+export function app(appName, inputOrCbOrOptions, cb) {
+    let input;
+    let handler;
+    let credentials;
+    let defaultMaxRetries;
+    if (typeof inputOrCbOrOptions === "function") {
+        input = {};
+        handler = inputOrCbOrOptions;
+    }
+    else if ("handler" in inputOrCbOrOptions) {
+        const opts = inputOrCbOrOptions;
+        input = opts.input;
+        handler = opts.handler;
+        credentials = opts.credentials;
+        defaultMaxRetries = opts.maxRetries;
+    }
+    else {
+        input = inputOrCbOrOptions;
+        handler = cb;
+    }
+    currentContext.current?.apps.register(appName, input, handler, credentials);
+    return (jobId, params = {}, options) => {
+        z.object(input).parse(params);
+        const maxRetries = options?.maxRetries ?? defaultMaxRetries;
+        const job = {
+            jobId,
+            appId: appName,
+            credentials: credentials?.map((cred) => ({ name: cred.name })) ?? [],
+            parentJobId: processingJobContext.getStore()?.currentJobId ?? null,
+            startedAt: null,
+            completedAt: null,
+            input: params,
+            output: null,
+            workerId: null,
+            maxRetries,
+        };
+        currentContext.current?.jobs.load(job);
+        return job;
+    };
+}

package/lib/esm/flow/loader.d.ts

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

package/lib/esm/flow/loader.js

@@ -0,0 +1,227 @@
+import { currentContext } from "./current.js";
+import { processingJobContext } from "./worker_ctx.js";
+import { EnvConfigs } from "./configs/env-configs.js";
+import { FileContextReflect } from "./context-reflects/file-context-reflect.js";
+import { CliHttpReflect } from "./context-reflects/cli-http-reflect.js";
+import { DsnReflect } from "./context-reflects/dsn-reflect.js";
+import { Queue } from "./utils/queue.js";
+import { ulid } from "ulid";
+import { RunMode } from "./constants/run-mode.js";
+import cluster from "node:cluster";
+import { JSONRPCTransporter, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCNotification, EVENT_NAME, } from "./util/json-rpc-transporter.js";
+const configs = await EnvConfigs.configs();
+const { context } = await FileContextReflect.load(configs.contextPath, {
+    disabled: configs.disableContextFile,
+});
+if (configs.disableLoadJob) {
+    context.configs.enableLoadJob = false;
+}
+currentContext.current = context;
+if (configs.cliInspectorUrl !== null) {
+    CliHttpReflect.attach(context, configs.cliInspectorUrl);
+}
+if (configs.dsn !== null) {
+    DsnReflect.attach(context, { dsn: configs.dsn });
+}
+const jobQueue = new Queue();
+const enqueuePendingJobs = () => {
+    for (const job of Object.values(context.manifest.jobs)) {
+        const jobIsPending = job.completedAt === null || job.completedAt === undefined;
+        if (jobIsPending) {
+            jobQueue.enqueue(job);
+        }
+    }
+};
+jobQueue.subscribe(async (job) => {
+    await processingJobContext.run({ processingId: ulid(), currentJobId: job.jobId }, async () => {
+        try {
+            context.jobs.start(job, new Date());
+            const app = await context.apps.get(job.appId);
+            if (!app) {
+                throw new Error(`App with id ${job.appId} not found for job ${job.jobId}`);
+            }
+            const output = await app.cb(job.input, job);
+            context.jobs.done(job.jobId, output, new Date());
+        }
+        catch (err) {
+            context.jobs.error(job.jobId, err instanceof Error ? err : new Error(String(err)));
+        }
+    });
+});
+const setupInProcessLoader = async () => {
+    context.events.addEventListener("job_loaded", (jobId) => {
+        const job = context.jobs.get(jobId);
+        if (job && !job.completedAt) {
+            jobQueue.enqueue(job);
+        }
+    });
+    enqueuePendingJobs();
+};
+const setupClusterPrimaryLoader = async () => {
+    console.log("Primary process started");
+    const fork = async (options) => {
+        const online = Promise.withResolvers();
+        const workerReady = Promise.withResolvers();
+        const worker = cluster
+            .fork({
+            ...process.env,
+            PIKA_RUN_MODE: RunMode.CLUSTER_WORKER,
+            PIKA_CONTEXT_PATH: undefined, // Workers should not read the context file directly
+            PIKA_DISABLE_CONTEXT_FILE: "true", // Ensure workers do not attempt to load context file
+        })
+            .on("online", () => {
+            online.resolve(true);
+        });
+        const workerTransporter = new JSONRPCTransporter({
+            connect: (events) => {
+                worker.on("message", (msg) => {
+                    if (isJSONRPCRequest(msg))
+                        events.emit(EVENT_NAME.REQUEST_TRANSPORTER_TO_CONNECTION, msg);
+                    else if (isJSONRPCResponse(msg))
+                        events.emit(EVENT_NAME.RESPONSE_TRANSPORTER_TO_CONNECTION, msg);
+                    else if (isJSONRPCNotification(msg))
+                        events.emit(EVENT_NAME.NOTIFICATION_TRANSPORTER_TO_CONNECTION, msg);
+                });
+                events.addEventListener(EVENT_NAME.REQUEST_CONNECTION_TO_TRANSPORTER, (req) => worker.send(req));
+                events.addEventListener(EVENT_NAME.RESPONSE_CONNECTION_TO_TRANSPORTER, (res) => worker.send(res));
+                events.addEventListener(EVENT_NAME.NOTIFICATION_CONNECTION_TO_TRANSPORTER, (notif) => worker.send(notif));
+            },
+            onRequest: JSONRPCTransporter.router({
+                "worker.ready": async () => {
+                    workerReady.resolve(true);
+                    return true;
+                },
+                "job.create": async (params) => {
+                    const { job } = params;
+                    context.manifest.jobs[job.jobId] ??= job;
+                    context.events.emit("job_loaded", job.jobId);
+                    context.events.emit("manifest_updated");
+                    return true;
+                },
+            }),
+            onNotification: JSONRPCTransporter.notificationRouter({}),
+        });
+        await online.promise;
+        await workerReady.promise;
+        options.onStart();
+        const response = await workerTransporter.request({
+            jsonrpc: "2.0",
+            id: ulid(),
+            method: "run.job",
+            params: { job: options.job },
+        });
+        if (response.error) {
+            options.onError(new Error(response.error.message));
+        }
+        else {
+            const result = response.result;
+            if (result.ok) {
+                options.onDone(result.output);
+            }
+            else {
+                options.onError(result.error instanceof Error
+                    ? result.error
+                    : new Error(String(result.error)));
+            }
+        }
+        await workerTransporter.request({
+            jsonrpc: "2.0",
+            id: ulid(),
+            method: "worker.end",
+            params: {},
+        });
+        worker.kill();
+    };
+    context.events.addEventListener("job_loaded", async (jobId) => {
+        const job = context.jobs.get(jobId);
+        if (job && !job.completedAt) {
+            await fork({
+                job: job,
+                onStart: () => {
+                    context.jobs.start(job.jobId, new Date());
+                },
+                onDone: (output) => {
+                    context.jobs.done(job.jobId, output, new Date());
+                },
+                onError: (err) => {
+                    context.jobs.error(job.jobId, err);
+                },
+            });
+        }
+    });
+    enqueuePendingJobs();
+};
+const setupClusterWorkerLoader = async () => {
+    let onProcessMessage;
+    const processTransporter = new JSONRPCTransporter({
+        connect: (events) => {
+            onProcessMessage = (msg) => {
+                if (isJSONRPCRequest(msg))
+                    events.emit(EVENT_NAME.REQUEST_TRANSPORTER_TO_CONNECTION, msg);
+                else if (isJSONRPCResponse(msg))
+                    events.emit(EVENT_NAME.RESPONSE_TRANSPORTER_TO_CONNECTION, msg);
+                else if (isJSONRPCNotification(msg))
+                    events.emit(EVENT_NAME.NOTIFICATION_TRANSPORTER_TO_CONNECTION, msg);
+            };
+            process.on("message", onProcessMessage);
+            events.addEventListener(EVENT_NAME.REQUEST_CONNECTION_TO_TRANSPORTER, (req) => process.send?.(req));
+            events.addEventListener(EVENT_NAME.RESPONSE_CONNECTION_TO_TRANSPORTER, (res) => process.send?.(res));
+            events.addEventListener(EVENT_NAME.NOTIFICATION_CONNECTION_TO_TRANSPORTER, (notif) => process.send?.(notif));
+        },
+        onRequest: JSONRPCTransporter.router({
+            "run.job": async (params) => {
+                const { promise, resolve } = Promise.withResolvers();
+                context.events.addEventListener("job_done", function onJobDone(jobId) {
+                    if (jobId === params.job.jobId) {
+                        context.events.removeEventListener("job_done", onJobDone);
+                        resolve({
+                            ok: true,
+                            output: context.jobs.get(jobId)?.output ?? {},
+                            error: null,
+                        });
+                    }
+                });
+                context.events.addEventListener("job_error", function onJobError(jobId, err) {
+                    if (jobId === params.job.jobId) {
+                        context.events.removeEventListener("job_error", onJobError);
+                        resolve({ ok: false, output: null, error: err });
+                    }
+                });
+                jobQueue.enqueue(params.job);
+                return await promise;
+            },
+            "worker.end": async () => {
+                if (onProcessMessage)
+                    process.off("message", onProcessMessage);
+                context.events.removeAllListeners();
+            },
+        }),
+        onNotification: JSONRPCTransporter.notificationRouter({}),
+    });
+    // Forward new jobs created inside callbacks to the primary
+    context.events.addEventListener("job_created", async (jobId) => {
+        const job = context.jobs.get(jobId);
+        if (job) {
+            await processTransporter.request({
+                jsonrpc: "2.0",
+                id: ulid(),
+                method: "job.create",
+                params: { job },
+            });
+        }
+    });
+    // Notify primary that this worker is ready to receive jobs
+    await processTransporter.request({
+        jsonrpc: "2.0",
+        id: ulid(),
+        method: "worker.ready",
+        params: { workerId: cluster.worker?.id },
+    });
+};
+const setups = {
+    [RunMode.IN_PROCESS]: setupInProcessLoader,
+    [RunMode.CLUSTER_PRIMARY]: setupClusterPrimaryLoader,
+    [RunMode.CLUSTER_WORKER]: setupClusterWorkerLoader,
+};
+const setup = setups[configs.runMode];
+await setup?.();

package/lib/esm/flow/util/json-rpc-transporter.d.ts

@@ -0,0 +1,80 @@
+import { EventManager } from "../utils/event-manager.js";
+export type JSONRPCRequest = {
+    jsonrpc: "2.0";
+    id: string;
+    method: string;
+    params: any;
+};
+export type JSONRPCNotification = {
+    jsonrpc: "2.0";
+    method: string;
+    params: any;
+};
+export type JSONRPCResponse = {
+    jsonrpc: "2.0";
+    id: string;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+};
+export declare const isJSONRPCResponse: (value: unknown) => value is JSONRPCResponse;
+export declare const isJSONRPCRequest: (value: unknown) => value is JSONRPCRequest;
+export declare const isJSONRPCNotification: (value: unknown) => value is JSONRPCNotification;
+export declare const notfoundJSONRPCResponse: (id: string) => JSONRPCResponse;
+export declare const internalErrorJSONRPCResponse: (id: string, error: Error) => JSONRPCResponse;
+export declare const createJSONRPCResponseRouter: (routes: Record<string, (params: any) => Promise<any>>) => (request: JSONRPCRequest) => Promise<JSONRPCResponse>;
+export declare const createJSONRPCNotificationRouter: (routes: Record<string, (params: any) => Promise<any>>) => (request: JSONRPCRequest) => Promise<void>;
+declare class Logger {
+    private enabled;
+    enable(): this;
+    disable(): this;
+    log(message: string): void;
+}
+export declare enum EVENT_NAME {
+    REQUEST_CONNECTION_TO_TRANSPORTER = "REQUEST_CONNECTION_TO_TRANSPORTER",
+    REQUEST_TRANSPORTER_TO_CONNECTION = "REQUEST_TRANSPORTER_TO_CONNECTION",
+    RESPONSE_CONNECTION_TO_TRANSPORTER = "RESPONSE_CONNECTION_TO_TRANSPORTER",
+    RESPONSE_TRANSPORTER_TO_CONNECTION = "RESPONSE_TRANSPORTER_TO_CONNECTION",
+    NOTIFICATION_CONNECTION_TO_TRANSPORTER = "NOTIFICATION_CONNECTION_TO_TRANSPORTER",
+    NOTIFICATION_TRANSPORTER_TO_CONNECTION = "NOTIFICATION_TRANSPORTER_TO_CONNECTION"
+}
+export type JSONRPCTransporterEvents = {
+    [EVENT_NAME.REQUEST_CONNECTION_TO_TRANSPORTER]: (request: JSONRPCRequest) => void;
+    [EVENT_NAME.RESPONSE_CONNECTION_TO_TRANSPORTER]: (response: JSONRPCResponse) => void;
+    [EVENT_NAME.REQUEST_TRANSPORTER_TO_CONNECTION]: (request: JSONRPCRequest) => void;
+    [EVENT_NAME.RESPONSE_TRANSPORTER_TO_CONNECTION]: (response: JSONRPCResponse) => void;
+    [EVENT_NAME.NOTIFICATION_CONNECTION_TO_TRANSPORTER]: (notification: JSONRPCNotification) => void;
+    [EVENT_NAME.NOTIFICATION_TRANSPORTER_TO_CONNECTION]: (notification: JSONRPCNotification) => void;
+};
+export declare class JSONRPCTransporter {
+    events: EventManager<JSONRPCTransporterEvents>;
+    constructor(options?: {
+        connect?: (events: EventManager<JSONRPCTransporterEvents>) => void;
+        onRequest?: (request: JSONRPCRequest) => Promise<JSONRPCResponse>;
+        onNotification?: (notification: JSONRPCNotification) => Promise<void>;
+    });
+    notification(request: JSONRPCNotification): Promise<void>;
+    request(request: JSONRPCRequest): Promise<JSONRPCResponse>;
+    static router: (routes: Record<string, (params: any) => Promise<any>>) => (request: JSONRPCRequest) => Promise<JSONRPCResponse>;
+    static notificationRouter: (routes: Record<string, (params: any) => Promise<any>>) => (request: JSONRPCRequest) => Promise<void>;
+}
+/** @deprecated Use JSONRPCTransporter instead */
+export declare class deprecated_JSONRPCTransporter {
+    private channel;
+    private requestHandler?;
+    private notificationHandler?;
+    logger: Logger;
+    constructor(channel: {
+        removeListener: (event: "message", listener: (message: unknown) => void) => void;
+        addListener: (event: "message", listener: (message: unknown) => void) => void;
+        send?: (message: unknown, cb?: (err: Error | null) => void) => boolean;
+    }, requestHandler?: ((request: JSONRPCRequest) => Promise<JSONRPCResponse>) | undefined, notificationHandler?: ((notification: JSONRPCNotification) => Promise<void>) | undefined);
+    send(message: unknown): Promise<void>;
+    sendNotification(request: JSONRPCNotification): Promise<void>;
+    sendRequest(request: JSONRPCRequest): Promise<JSONRPCResponse>;
+    sendResponse(response: JSONRPCResponse): void;
+}
+export {};

package/lib/esm/flow/util/json-rpc-transporter.js

@@ -0,0 +1,175 @@
+import { EventManager } from "../utils/event-manager.js";
+export const isJSONRPCResponse = (value) => typeof value === "object" &&
+    value !== null &&
+    "jsonrpc" in value &&
+    "id" in value;
+export const isJSONRPCRequest = (value) => typeof value === "object" &&
+    value !== null &&
+    "jsonrpc" in value &&
+    "id" in value &&
+    typeof value.id === "string" &&
+    "method" in value;
+export const isJSONRPCNotification = (value) => typeof value === "object" &&
+    value !== null &&
+    "jsonrpc" in value &&
+    "method" in value &&
+    !("id" in value);
+export const notfoundJSONRPCResponse = (id) => ({
+    jsonrpc: "2.0",
+    id: id,
+    error: { code: -32601, message: "Method not found" },
+});
+export const internalErrorJSONRPCResponse = (id, error) => ({
+    jsonrpc: "2.0",
+    id: id,
+    error: {
+        code: -32603,
+        message: "Internal error",
+        data: error instanceof Error
+            ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            }
+            : { value: error },
+    },
+});
+export const createJSONRPCResponseRouter = (routes) => async (request) => {
+    const handler = routes[request.method];
+    if (!handler)
+        return notfoundJSONRPCResponse(request.id);
+    try {
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: await handler(request.params),
+        };
+    }
+    catch (error) {
+        return internalErrorJSONRPCResponse(request.id, error instanceof Error ? error : new Error(String(error)));
+    }
+};
+export const createJSONRPCNotificationRouter = (routes) => async (request) => {
+    const handler = routes[request.method];
+    if (!handler)
+        return;
+    try {
+        await handler(request.params);
+    }
+    catch (error) {
+        // Notifications do not expect a response, so we just log the error
+        console.error("Error handling JSON-RPC notification:", error instanceof Error ? error : new Error(String(error)));
+    }
+};
+class Logger {
+    enabled;
+    enable() {
+        this.enabled = true;
+        return this;
+    }
+    disable() {
+        this.enabled = false;
+        return this;
+    }
+    log(message) {
+        if (this.enabled) {
+            console.log(message);
+        }
+    }
+}
+export var EVENT_NAME;
+(function (EVENT_NAME) {
+    EVENT_NAME["REQUEST_CONNECTION_TO_TRANSPORTER"] = "REQUEST_CONNECTION_TO_TRANSPORTER";
+    EVENT_NAME["REQUEST_TRANSPORTER_TO_CONNECTION"] = "REQUEST_TRANSPORTER_TO_CONNECTION";
+    EVENT_NAME["RESPONSE_CONNECTION_TO_TRANSPORTER"] = "RESPONSE_CONNECTION_TO_TRANSPORTER";
+    EVENT_NAME["RESPONSE_TRANSPORTER_TO_CONNECTION"] = "RESPONSE_TRANSPORTER_TO_CONNECTION";
+    EVENT_NAME["NOTIFICATION_CONNECTION_TO_TRANSPORTER"] = "NOTIFICATION_CONNECTION_TO_TRANSPORTER";
+    EVENT_NAME["NOTIFICATION_TRANSPORTER_TO_CONNECTION"] = "NOTIFICATION_TRANSPORTER_TO_CONNECTION";
+})(EVENT_NAME || (EVENT_NAME = {}));
+export class JSONRPCTransporter {
+    events = new EventManager();
+    constructor(options) {
+        if (options?.onRequest) {
+            this.events.addEventListener(EVENT_NAME.REQUEST_TRANSPORTER_TO_CONNECTION, async (request) => {
+                const response = await options.onRequest(request);
+                this.events.emit(EVENT_NAME.RESPONSE_CONNECTION_TO_TRANSPORTER, response);
+            });
+        }
+        if (options?.onNotification) {
+            this.events.addEventListener(EVENT_NAME.NOTIFICATION_TRANSPORTER_TO_CONNECTION, async (notification) => {
+                await options.onNotification(notification);
+            });
+        }
+        options?.connect?.(this.events);
+    }
+    async notification(request) {
+        this.events.emit(EVENT_NAME.NOTIFICATION_CONNECTION_TO_TRANSPORTER, request);
+    }
+    async request(request) {
+        const responsePromise = Promise.withResolvers();
+        const unsub = this.events.addEventListener(EVENT_NAME.RESPONSE_TRANSPORTER_TO_CONNECTION, (response) => {
+            if (response.id === request.id) {
+                responsePromise.resolve(response);
+                unsub();
+            }
+        });
+        this.events.emit(EVENT_NAME.REQUEST_CONNECTION_TO_TRANSPORTER, request);
+        return await responsePromise.promise;
+    }
+    static router = createJSONRPCResponseRouter;
+    static notificationRouter = createJSONRPCNotificationRouter;
+}
+/** @deprecated Use JSONRPCTransporter instead */
+export class deprecated_JSONRPCTransporter {
+    channel;
+    requestHandler;
+    notificationHandler;
+    logger = new Logger();
+    constructor(channel, requestHandler, notificationHandler) {
+        this.channel = channel;
+        this.requestHandler = requestHandler;
+        this.notificationHandler = notificationHandler;
+        this.channel.addListener("message", async (message) => {
+            this.logger.log(`Received message on channel: ${JSON.stringify(message)}`);
+            if (isJSONRPCRequest(message) && this.requestHandler) {
+                this.logger.log(`Received request: ${JSON.stringify(message)}`);
+                const response = await this.requestHandler(message);
+                this.sendResponse(response);
+            }
+            if (isJSONRPCNotification(message) && this.notificationHandler) {
+                this.logger.log(`Received notification: ${JSON.stringify(message)}`);
+                await this.notificationHandler(message);
+            }
+        });
+    }
+    async send(message) {
+        this.logger.log(`Sending message: ${JSON.stringify(message)}`);
+        await new Promise((resolve, reject) => {
+            return this.channel.send?.(message, (err) => err ? reject(err) : resolve(null));
+        });
+    }
+    async sendNotification(request) {
+        this.logger.log(`Sending notification: ${JSON.stringify(request)}`);
+        await new Promise((resolve, reject) => {
+            return this.channel.send?.(request, (err) => err ? reject(err) : resolve(null));
+        });
+    }
+    async sendRequest(request) {
+        const response = Promise.withResolvers();
+        const listener = (message) => {
+            this.logger.log(`Received message on channel: ${JSON.stringify(message)}`);
+            if (isJSONRPCResponse(message) && message.id === request.id) {
+                response.resolve(message);
+                this.channel.removeListener("message", listener);
+            }
+        };
+        this.channel.addListener("message", listener);
+        this.logger.log(`Sending request: ${JSON.stringify(request)}`);
+        await new Promise((resolve, reject) => this.channel.send?.(request, (err) => err ? reject(err) : resolve(null)));
+        return response.promise;
+    }
+    sendResponse(response) {
+        this.logger.log(`Sending response: ${JSON.stringify(response)}`);
+        this.channel.send?.(response);
+    }
+}

package/lib/esm/flow/utils/bytes.d.ts

@@ -0,0 +1,29 @@
+declare const UNIT_MAP: readonly [{
+    readonly units: readonly ["b", "bytes"];
+    readonly bytes: 1n;
+}, {
+    readonly units: readonly ["kb", "kilobytes"];
+    readonly bytes: 1000n;
+}, {
+    readonly units: readonly ["mb", "megabytes"];
+    readonly bytes: 1000000n;
+}, {
+    readonly units: readonly ["gb", "gigabytes"];
+    readonly bytes: 1000000000n;
+}, {
+    readonly units: readonly ["tb", "terabytes"];
+    readonly bytes: 1000000000000n;
+}, {
+    readonly units: readonly ["pb", "petabytes"];
+    readonly bytes: 1000000000000000n;
+}];
+export type BytesUnit = (typeof UNIT_MAP)[number]["units"][number];
+export type BytesInput = Partial<Record<BytesUnit, bigint | number>>;
+export declare class Bytes {
+    private readonly _bytes;
+    private constructor();
+    static from(input: BytesInput): Bytes;
+    total(unit?: BytesUnit): bigint;
+    get bytes(): bigint;
+}
+export {};

package/lib/esm/flow/utils/bytes.js

@@ -0,0 +1,32 @@
+const UNIT_MAP = [
+    { units: ["b", "bytes"], bytes: 1n },
+    { units: ["kb", "kilobytes"], bytes: 1000n },
+    { units: ["mb", "megabytes"], bytes: 1000000n },
+    { units: ["gb", "gigabytes"], bytes: 1000000000n },
+    { units: ["tb", "terabytes"], bytes: 1000000000000n },
+    { units: ["pb", "petabytes"], bytes: 1000000000000000n },
+];
+export class Bytes {
+    _bytes;
+    constructor(_bytes) {
+        this._bytes = _bytes;
+    }
+    static from(input) {
+        let total = 0n;
+        for (const entry of UNIT_MAP) {
+            for (const unit of entry.units) {
+                const val = input[unit];
+                if (val !== undefined)
+                    total += BigInt(val) * entry.bytes;
+            }
+        }
+        return new Bytes(total);
+    }
+    total(unit = "b") {
+        const entry = UNIT_MAP.find((e) => e.units.includes(unit));
+        return this._bytes / (entry?.bytes ?? 1n);
+    }
+    get bytes() {
+        return this._bytes;
+    }
+}

package/lib/esm/flow/utils/event-manager.d.ts

@@ -0,0 +1,11 @@
+export declare class EventManager<T extends Record<string, (...args: any[]) => void>> {
+    private _eventListeners;
+    private _weakWrapper;
+    constructor();
+    addEventListener<K extends keyof T, P extends Parameters<T[K]> = Parameters<T[K]>>(event: K, listener: (...args: P) => void, options?: {
+        once?: boolean;
+    }): any;
+    removeEventListener<K extends keyof T, P extends Parameters<T[K]> = Parameters<T[K]>>(event: K, listener: (...args: P) => void): any;
+    removeAllListeners(): void;
+    emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): any;
+}

package/lib/esm/flow/utils/event-manager.js

@@ -0,0 +1,41 @@
+export class EventManager {
+    _eventListeners = new Map();
+    _weakWrapper = new WeakMap();
+    constructor() {
+        this._eventListeners = new Map();
+    }
+    addEventListener(event, listener, options) {
+        const once = options?.once ?? false;
+        const wrapper = (...args) => {
+            listener(...args);
+            if (once) {
+                this.removeEventListener(event, listener);
+            }
+        };
+        this._weakWrapper.set(listener, wrapper);
+        const cbs = this._eventListeners.get(event) ?? new Set();
+        cbs.add(wrapper);
+        this._eventListeners.set(event, cbs);
+        return () => this.removeEventListener(event, listener);
+    }
+    removeEventListener(event, listener) {
+        const cbs = this._eventListeners.get(event);
+        const wrapper = this._weakWrapper.get(listener);
+        if (wrapper) {
+            cbs?.delete(wrapper);
+            this._weakWrapper.delete(listener);
+        }
+        if (cbs?.size === 0) {
+            this._eventListeners.delete(event);
+        }
+    }
+    removeAllListeners() {
+        this._eventListeners.clear();
+    }
+    emit(event, ...args) {
+        const cbs = this._eventListeners.get(event);
+        cbs?.forEach((listener) => {
+            listener(...args);
+        });
+    }
+}