@neofinancial/chrono 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Neo Financial
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/backoff-strategy.d.ts

@@ -0,0 +1,64 @@
+/** Input for calculating the next backoff delay. */
+export type BackoffStrategyInput = {
+    /** The number of retries already attempted (0 for the first retry). */
+    retryAttempt: number;
+};
+export type DelayMs = number;
+/**
+ * A function that calculates the backoff delay in milliseconds.
+ * @param input - Contains information like the current retry number.
+ * @returns The delay duration in milliseconds.
+ */
+export type BackoffStrategy = (input: BackoffStrategyInput) => DelayMs;
+/**
+ * Creates a strategy that provides no delay (immediate retry).
+ */
+export declare function createNoBackoffStrategy(): BackoffStrategy;
+export interface FixedBackoffStrategyConfig {
+    /** The constant delay in milliseconds. */
+    readonly delayMs: number;
+}
+/**
+ * Creates a strategy that waits a fixed amount of time.
+ */
+export declare function createFixedBackoffStrategy(config: FixedBackoffStrategyConfig): BackoffStrategy;
+export interface LinearBackoffStrategyConfig {
+    /** The base delay for all retires that will be incremented off of */
+    readonly baseDelayMs?: number;
+    /** The amount to increase the delay by for each subsequent retry in milliseconds. */
+    readonly incrementMs: number;
+}
+/**
+ * Creates a strategy where the delay increases linearly.
+ * Delay = (incrementMs * retryAttempt)
+ */
+export declare function createLinearBackoffStrategy(config: LinearBackoffStrategyConfig): BackoffStrategy;
+export interface ExponentialBackoffStrategyConfig {
+    /** The base delay for the first retry (retryAttempt = 0) in milliseconds. */
+    readonly baseDelayMs: number;
+    /** The maximum delay in milliseconds. Defaults to Infinity. */
+    readonly maxDelayMs?: number;
+    /** Type of jitter to apply. Defaults to 'none'. */
+    readonly jitter?: 'none' | 'full' | 'equal';
+}
+/**
+ * Creates a strategy where the delay increases exponentially, potentially with jitter.
+ * Base Delay Formula = baseDelayMs * (2 ** retryAttempt)
+ */
+export declare function createExponentialBackoffStrategy(config: ExponentialBackoffStrategyConfig): BackoffStrategy;
+export type BackoffStrategyType = 'none' | 'fixed' | 'linear' | 'exponential';
+export type BackoffStrategyOptions = {
+    type: 'none';
+} | ({
+    type: 'fixed';
+} & FixedBackoffStrategyConfig) | ({
+    type: 'linear';
+} & LinearBackoffStrategyConfig) | ({
+    type: 'exponential';
+} & ExponentialBackoffStrategyConfig);
+/**
+ * Factory function to create a backoff strategy based on type and configuration.
+ * @param options - Configuration object including the strategy type.
+ * @returns A BackoffStrategy function.
+ */
+export declare function backoffStrategyFactory(options?: BackoffStrategyOptions): BackoffStrategy;

package/build/backoff-strategy.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNoBackoffStrategy = createNoBackoffStrategy;
+exports.createFixedBackoffStrategy = createFixedBackoffStrategy;
+exports.createLinearBackoffStrategy = createLinearBackoffStrategy;
+exports.createExponentialBackoffStrategy = createExponentialBackoffStrategy;
+exports.backoffStrategyFactory = backoffStrategyFactory;
+/**
+ * Creates a strategy that provides no delay (immediate retry).
+ */
+function createNoBackoffStrategy() {
+    return (_input) => 0;
+}
+/**
+ * Creates a strategy that waits a fixed amount of time.
+ */
+function createFixedBackoffStrategy(config) {
+    return (_input) => config.delayMs;
+}
+/**
+ * Creates a strategy where the delay increases linearly.
+ * Delay = (incrementMs * retryAttempt)
+ */
+function createLinearBackoffStrategy(config) {
+    const { incrementMs, baseDelayMs = 0 } = config;
+    return (input) => {
+        return baseDelayMs + input.retryAttempt * incrementMs;
+    };
+}
+/**
+ * Creates a strategy where the delay increases exponentially, potentially with jitter.
+ * Base Delay Formula = baseDelayMs * (2 ** retryAttempt)
+ */
+function createExponentialBackoffStrategy(config) {
+    const { baseDelayMs, maxDelayMs = Number.POSITIVE_INFINITY, jitter = 'none' } = config;
+    return (input) => {
+        const exponentialDelay = baseDelayMs * 2 ** input.retryAttempt;
+        const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+        switch (jitter) {
+            case 'full':
+                // Full Jitter: random_between(0, cappedDelay)
+                return Math.floor(Math.random() * cappedDelay);
+            case 'equal': {
+                // Equal Jitter: (cappedDelay / 2) + random_between(0, cappedDelay / 2)
+                const halfDelay = cappedDelay / 2;
+                return halfDelay + Math.random() * halfDelay;
+            }
+            case 'none':
+                // No Jitter
+                return cappedDelay;
+            default: {
+                // This should be caught by TypeScript if options type is correct
+                const _exhaustiveCheck = jitter;
+                throw new Error('Unknown jitter type for exponential backoff strategy');
+            }
+        }
+    };
+}
+const DEFAULT_BACKOFF_STRATEGY = {
+    type: 'linear',
+    incrementMs: 2000,
+};
+/**
+ * Factory function to create a backoff strategy based on type and configuration.
+ * @param options - Configuration object including the strategy type.
+ * @returns A BackoffStrategy function.
+ */
+function backoffStrategyFactory(options = DEFAULT_BACKOFF_STRATEGY) {
+    switch (options.type) {
+        case 'none':
+            return createNoBackoffStrategy();
+        case 'fixed':
+            // No need to destructure 'type', pass the rest
+            return createFixedBackoffStrategy(options);
+        case 'linear':
+            return createLinearBackoffStrategy(options);
+        case 'exponential':
+            return createExponentialBackoffStrategy(options);
+        default: {
+            // This should be caught by TypeScript if options type is correct
+            const _exhaustiveCheck = options;
+            throw new Error('Unknown backoff strategy type');
+        }
+    }
+}
+//# sourceMappingURL=backoff-strategy.js.map

package/build/backoff-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff-strategy.js","sourceRoot":"","sources":["../src/backoff-strategy.ts"],"names":[],"mappings":";;AAkBA,0DAEC;AASD,gEAEC;AAaD,kEAKC;AAcD,4EA0BC;AAoBD,wDAiBC;AA/GD;;GAEG;AACH,SAAgB,uBAAuB;IACrC,OAAO,CAAC,MAA4B,EAAE,EAAE,CAAC,CAAC,CAAC;AAC7C,CAAC;AAMD;;GAEG;AACH,SAAgB,0BAA0B,CAAC,MAAkC;IAC3E,OAAO,CAAC,MAA4B,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC;AAC1D,CAAC;AASD;;;GAGG;AACH,SAAgB,2BAA2B,CAAC,MAAmC;IAC7E,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC;IAChD,OAAO,CAAC,KAA2B,EAAE,EAAE;QACrC,OAAO,WAAW,GAAG,KAAK,CAAC,YAAY,GAAG,WAAW,CAAC;IACxD,CAAC,CAAC;AACJ,CAAC;AAUD;;;GAGG;AACH,SAAgB,gCAAgC,CAAC,MAAwC;IACvF,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,MAAM,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC;IAEvF,OAAO,CAAC,KAA2B,EAAE,EAAE;QACrC,MAAM,gBAAgB,GAAG,WAAW,GAAG,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC;QAC/D,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;QAE3D,QAAQ,MAAM,EAAE,CAAC;YACf,KAAK,MAAM;gBACT,8CAA8C;gBAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,WAAW,CAAC,CAAC;YACjD,KAAK,OAAO,CAAC,CAAC,CAAC;gBACb,uEAAuE;gBACvE,MAAM,SAAS,GAAG,WAAW,GAAG,CAAC,CAAC;gBAClC,OAAO,SAAS,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC;YAC/C,CAAC;YACD,KAAK,MAAM;gBACT,YAAY;gBACZ,OAAO,WAAW,CAAC;YACrB,OAAO,CAAC,CAAC,CAAC;gBACR,iEAAiE;gBACjE,MAAM,gBAAgB,GAAU,MAAM,CAAC;gBACvC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;YAC1E,CAAC;QACH,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAUD,MAAM,wBAAwB,GAA2B;IACvD,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,IAAI;CACT,CAAC;AAEX;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,UAAkC,wBAAwB;IAC/F,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;QACrB,KAAK,MAAM;YACT,OAAO,uBAAuB,EAAE,CAAC;QACnC,KAAK,OAAO;YACV,+CAA+C;YAC/C,OAAO,0BAA0B,CAAC,OAAO,CAAC,CAAC;QAC7C,KAAK,QAAQ;YACX,OAAO,2BAA2B,CAAC,OAAO,CAAC,CAAC;QAC9C,KAAK,aAAa;YAChB,OAAO,gCAAgC,CAAC,OAAO,CAAC,CAAC;QACnD,OAAO,CAAC,CAAC,CAAC;YACR,iEAAiE;YACjE,MAAM,gBAAgB,GAAU,OAAO,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;AACH,CAAC"}

package/build/chrono.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter } from 'node:stream';
+import type { BackoffStrategyOptions } from './backoff-strategy';
+import type { Datastore, ScheduleInput, Task } from './datastore';
+import { type Processor } from './processors';
+import type { ProcessorConfiguration } from './processors/create-processor';
+export type TaskMappingBase = Record<string, unknown>;
+export type ScheduleTaskInput<TaskKind, TaskData, DatastoreOptions> = ScheduleInput<TaskKind, TaskData, DatastoreOptions>;
+export type RegisterTaskHandlerInput<TaskKind, TaskData> = {
+    kind: TaskKind;
+    handler: (task: Task<TaskKind, TaskData>) => Promise<void>;
+    backoffStrategyOptions?: BackoffStrategyOptions;
+    processorConfiguration?: ProcessorConfiguration;
+};
+/**
+ * This is a type that represents the mapping of task kinds to their respective data types.
+ *
+ * Eg. shape of the TaskMapping type:
+ *
+ * type TaskMapping = {
+ *   "async-messaging": { someField: number };
+ *   "send-email": { url: string };
+ * };
+ *
+ */
+export declare class Chrono<TaskMapping extends TaskMappingBase, DatastoreOptions> extends EventEmitter {
+    private datastore;
+    private processors;
+    readonly exitTimeoutMs = 60000;
+    constructor(datastore: Datastore<TaskMapping, DatastoreOptions>);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    scheduleTask<TaskKind extends keyof TaskMapping>(input: ScheduleTaskInput<TaskKind, TaskMapping[TaskKind], DatastoreOptions>): Promise<Task<TaskKind, TaskMapping[TaskKind]>>;
+    deleteTask<TaskKind extends keyof TaskMapping>(taskId: string): Promise<Task<TaskKind, TaskMapping[TaskKind]> | undefined>;
+    registerTaskHandler<TaskKind extends Extract<keyof TaskMapping, string>>(input: RegisterTaskHandlerInput<TaskKind, TaskMapping[TaskKind]>): Processor<TaskKind, TaskMapping>;
+}

package/build/chrono.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chrono = void 0;
+const node_stream_1 = require("node:stream");
+const processors_1 = require("./processors");
+const promise_utils_1 = require("./utils/promise-utils");
+/**
+ * This is a type that represents the mapping of task kinds to their respective data types.
+ *
+ * Eg. shape of the TaskMapping type:
+ *
+ * type TaskMapping = {
+ *   "async-messaging": { someField: number };
+ *   "send-email": { url: string };
+ * };
+ *
+ */
+class Chrono extends node_stream_1.EventEmitter {
+    datastore;
+    processors = new Map();
+    exitTimeoutMs = 60_000;
+    constructor(datastore) {
+        super();
+        this.datastore = datastore;
+    }
+    async start() {
+        for (const processor of this.processors.values()) {
+            await processor.start();
+        }
+        this.emit('ready', { timestamp: new Date() });
+    }
+    async stop() {
+        const stopPromises = Array.from(this.processors.values()).map((processor) => processor.stop());
+        try {
+            await (0, promise_utils_1.promiseWithTimeout)(Promise.all(stopPromises), this.exitTimeoutMs);
+            this.emit('stopped', { timestamp: new Date() });
+        }
+        catch (error) {
+            this.emit('stop.failed', { error, timestamp: new Date() });
+        }
+        finally {
+            this.emit('close', { timestamp: new Date() });
+        }
+    }
+    async scheduleTask(input) {
+        const task = await this.datastore.schedule({
+            when: input.when,
+            kind: input.kind,
+            data: input.data,
+            datastoreOptions: input.datastoreOptions,
+        });
+        return task;
+    }
+    async deleteTask(taskId) {
+        const task = await this.datastore.delete(taskId);
+        return task;
+    }
+    registerTaskHandler(input) {
+        if (this.processors.has(input.kind)) {
+            throw new Error('Handler for task kind already exists');
+        }
+        const processor = (0, processors_1.createProcessor)({
+            kind: input.kind,
+            datastore: this.datastore,
+            handler: input.handler,
+            configuration: input.processorConfiguration,
+        });
+        this.processors.set(input.kind, processor);
+        return processor;
+    }
+}
+exports.Chrono = Chrono;
+//# sourceMappingURL=chrono.js.map

package/build/chrono.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chrono.js","sourceRoot":"","sources":["../src/chrono.ts"],"names":[],"mappings":";;;AAAA,6CAA2C;AAI3C,6CAA+D;AAE/D,yDAA2D;AAiB3D;;;;;;;;;;GAUG;AAEH,MAAa,MAA8D,SAAQ,0BAAY;IACrF,SAAS,CAA2C;IACpD,UAAU,GAAsE,IAAI,GAAG,EAAE,CAAC;IAEzF,aAAa,GAAG,MAAM,CAAC;IAEhC,YAAY,SAAmD;QAC7D,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;YACjD,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QAC1B,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;IAChD,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;QAE/F,IAAI,CAAC;YACH,MAAM,IAAA,kCAAkB,EAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;YAExE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;QAClD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;QAC7D,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,YAAY,CACvB,KAA2E;QAE3E,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;YACzC,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;SACzC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,KAAK,CAAC,UAAU,CACrB,MAAc;QAEd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAW,MAAM,CAAC,CAAC;QAE3D,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,mBAAmB,CACxB,KAAgE;QAEhE,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QAED,MAAM,SAAS,GAAG,IAAA,4BAAe,EAAC;YAChC,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,aAAa,EAAE,KAAK,CAAC,sBAAsB;SAC5C,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAE3C,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AAzED,wBAyEC"}

package/build/datastore.d.ts

@@ -0,0 +1,63 @@
+import type { TaskMappingBase } from './chrono';
+export declare const TaskStatus: {
+    readonly PENDING: "PENDING";
+    readonly CLAIMED: "CLAIMED";
+    readonly COMPLETED: "COMPLETED";
+    readonly FAILED: "FAILED";
+};
+export type TaskStatus = (typeof TaskStatus)[keyof typeof TaskStatus];
+export type Task<TaskKind, TaskData> = {
+    /** A unique identifier for the task */
+    id: string;
+    /** A human-readable name or type for the task */
+    kind: TaskKind;
+    /** The current status of the task */
+    status: TaskStatus;
+    /** The payload or data associated with the task */
+    data: TaskData;
+    /** The priority level of the task (lower numbers can indicate higher priority) */
+    priority?: number;
+    /** A key used for idempotency to prevent duplicate processing */
+    idempotencyKey?: string;
+    /** The original scheduled date when the task was first intended to run */
+    originalScheduleDate: Date;
+    /** The current scheduled execution date, which may change if rescheduled */
+    scheduledAt: Date;
+    /** The date the task is mark 'claimed */
+    claimedAt?: Date;
+    /** The date the task is mark 'completed' */
+    completedAt?: Date;
+    /** The date when the task was last executed (if any) */
+    lastExecutedAt?: Date;
+    /** A counter to track the number of times the task has been retried */
+    retryCount: number;
+};
+export type ScheduleInput<TaskKind, TaskData, DatastoreOptions> = {
+    when: Date;
+    kind: TaskKind;
+    data: TaskData;
+    priority?: number;
+    idempotencyKey?: string;
+    datastoreOptions?: DatastoreOptions;
+};
+export type ClaimTaskInput<TaskKind> = {
+    kind: TaskKind;
+    claimStaleTimeoutMs: number;
+};
+export type DeleteByIdempotencyKeyInput<TaskKind> = {
+    kind: TaskKind;
+    idempotencyKey: string;
+};
+export type DeleteOptions = {
+    force?: boolean;
+};
+export type DeleteInput<TaskKind> = DeleteByIdempotencyKeyInput<TaskKind> | string;
+export interface Datastore<TaskMapping extends TaskMappingBase, DatastoreOptions> {
+    schedule<TaskKind extends keyof TaskMapping>(input: ScheduleInput<TaskKind, TaskMapping[TaskKind], DatastoreOptions>): Promise<Task<TaskKind, TaskMapping[TaskKind]>>;
+    delete<TaskKind extends keyof TaskMapping>(taskId: string, options?: DeleteOptions): Promise<Task<TaskKind, TaskMapping[TaskKind]> | undefined>;
+    delete<TaskKind extends keyof TaskMapping>(key: DeleteByIdempotencyKeyInput<TaskKind>, options?: DeleteOptions): Promise<Task<TaskKind, TaskMapping[TaskKind]> | undefined>;
+    claim<TaskKind extends Extract<keyof TaskMapping, string>>(input: ClaimTaskInput<TaskKind>): Promise<Task<TaskKind, TaskMapping[TaskKind]> | undefined>;
+    unclaim<TaskKind extends keyof TaskMapping>(taskId: string, nextScheduledAt: Date): Promise<Task<TaskKind, TaskMapping[TaskKind]>>;
+    complete<TaskKind extends keyof TaskMapping>(taskId: string): Promise<Task<TaskKind, TaskMapping[TaskKind]>>;
+    fail<TaskKind extends keyof TaskMapping>(taskId: string): Promise<Task<TaskKind, TaskMapping[TaskKind]>>;
+}

package/build/datastore.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStatus = void 0;
+exports.TaskStatus = {
+    PENDING: 'PENDING',
+    CLAIMED: 'CLAIMED',
+    COMPLETED: 'COMPLETED',
+    FAILED: 'FAILED',
+};
+//# sourceMappingURL=datastore.js.map

package/build/datastore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore.js","sourceRoot":"","sources":["../src/datastore.ts"],"names":[],"mappings":";;;AAEa,QAAA,UAAU,GAAG;IACxB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;IACtB,MAAM,EAAE,QAAQ;CACR,CAAC"}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export { Chrono, type ScheduleTaskInput, type TaskMappingBase } from './chrono';
+export { TaskStatus, type ClaimTaskInput, type Datastore, type ScheduleInput, type Task, type DeleteInput, type DeleteOptions, type DeleteByIdempotencyKeyInput } from './datastore';

package/build/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStatus = exports.Chrono = void 0;
+var chrono_1 = require("./chrono");
+Object.defineProperty(exports, "Chrono", { enumerable: true, get: function () { return chrono_1.Chrono; } });
+var datastore_1 = require("./datastore");
+Object.defineProperty(exports, "TaskStatus", { enumerable: true, get: function () { return datastore_1.TaskStatus; } });
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,mCAAgF;AAAvE,gGAAA,MAAM,OAAA;AACf,yCAAsL;AAA7K,uGAAA,UAAU,OAAA"}

package/build/processors/create-processor.d.ts

@@ -0,0 +1,20 @@
+import type { Datastore, Task } from 'datastore';
+import type { TaskMappingBase } from '..';
+import { type BackoffStrategyOptions } from '../backoff-strategy';
+import type { Processor } from './processor';
+export type ProcessorConfiguration = {
+    maxConcurrency?: number;
+    claimIntervalMs?: number;
+    claimStaleTimeoutMs?: number;
+    idleIntervalMs?: number;
+    taskHandlerTimeoutMs?: number;
+    taskHandlerMaxRetries?: number;
+};
+export type CreateProcessorInput<TaskKind extends keyof TaskMapping, TaskMapping extends TaskMappingBase, DatastoreOptions> = {
+    kind: TaskKind;
+    datastore: Datastore<TaskMapping, DatastoreOptions>;
+    handler: (task: Task<TaskKind, TaskMapping[TaskKind]>) => Promise<void>;
+    configuration?: ProcessorConfiguration;
+    backoffStrategyOptions?: BackoffStrategyOptions;
+};
+export declare function createProcessor<TaskKind extends Extract<keyof TaskMapping, string>, TaskMapping extends TaskMappingBase, DatastoreOptions>(input: CreateProcessorInput<TaskKind, TaskMapping, DatastoreOptions>): Processor<TaskKind, TaskMapping>;

package/build/processors/create-processor.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProcessor = createProcessor;
+const backoff_strategy_1 = require("../backoff-strategy");
+const simple_processor_1 = require("./simple-processor");
+function createProcessor(input) {
+    const backoffStrategy = (0, backoff_strategy_1.backoffStrategyFactory)(input.backoffStrategyOptions);
+    // add more processors here
+    return new simple_processor_1.SimpleProcessor({
+        datastore: input.datastore,
+        kind: input.kind,
+        handler: input.handler,
+        maxConcurrency: input.configuration?.maxConcurrency,
+        backoffStrategy,
+        claimIntervalMs: input.configuration?.claimIntervalMs,
+        idleIntervalMs: input.configuration?.idleIntervalMs,
+        taskHandlerTimeoutMs: input.configuration?.taskHandlerTimeoutMs,
+        claimStaleTimeoutMs: input.configuration?.claimStaleTimeoutMs,
+        taskHandlerMaxRetries: input.configuration?.taskHandlerMaxRetries,
+    });
+}
+//# sourceMappingURL=create-processor.js.map

package/build/processors/create-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-processor.js","sourceRoot":"","sources":["../../src/processors/create-processor.ts"],"names":[],"mappings":";;AA2BA,0CAmBC;AA5CD,0DAA0F;AAE1F,yDAAqD;AAuBrD,SAAgB,eAAe,CAI7B,KAAoE;IACpE,MAAM,eAAe,GAAG,IAAA,yCAAsB,EAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC7E,2BAA2B;IAC3B,OAAO,IAAI,kCAAe,CAA0C;QAClE,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,cAAc,EAAE,KAAK,CAAC,aAAa,EAAE,cAAc;QACnD,eAAe;QACf,eAAe,EAAE,KAAK,CAAC,aAAa,EAAE,eAAe;QACrD,cAAc,EAAE,KAAK,CAAC,aAAa,EAAE,cAAc;QACnD,oBAAoB,EAAE,KAAK,CAAC,aAAa,EAAE,oBAAoB;QAC/D,mBAAmB,EAAE,KAAK,CAAC,aAAa,EAAE,mBAAmB;QAC7D,qBAAqB,EAAE,KAAK,CAAC,aAAa,EAAE,qBAAqB;KAClE,CAAC,CAAC;AACL,CAAC"}

package/build/processors/index.d.ts

@@ -0,0 +1,2 @@
+export { createProcessor } from './create-processor';
+export type { Processor } from './processor';

package/build/processors/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProcessor = void 0;
+var create_processor_1 = require("./create-processor");
+Object.defineProperty(exports, "createProcessor", { enumerable: true, get: function () { return create_processor_1.createProcessor; } });
+//# sourceMappingURL=index.js.map

package/build/processors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/processors/index.ts"],"names":[],"mappings":";;;AAAA,uDAAqD;AAA5C,mHAAA,eAAe,OAAA"}

package/build/processors/processor.d.ts

@@ -0,0 +1,35 @@
+import type { EventEmitter } from 'node:stream';
+import type { Task, TaskMappingBase } from '..';
+export type ProcessorEvents<TaskKind extends keyof TaskMapping, TaskMapping extends TaskMappingBase> = {
+    'task:claimed': [{
+        task: Task<TaskKind, TaskMapping[TaskKind]>;
+        timestamp: Date;
+    }];
+    'task:completed': [{
+        task: Task<TaskKind, TaskMapping[TaskKind]>;
+        timestamp: Date;
+    }];
+    'task:failed': [{
+        task: Task<TaskKind, TaskMapping[TaskKind]>;
+        error: Error;
+        timestamp: Date;
+    }];
+    'task:unclaimed': [{
+        task: Task<TaskKind, TaskMapping[TaskKind]>;
+        error: Error;
+        timestamp: Date;
+    }];
+    'task:completion:failed': [{
+        task: Task<TaskKind, TaskMapping[TaskKind]>;
+        error: Error;
+        timestamp: Date;
+    }];
+    'processloop:error': [{
+        error: Error;
+        timestamp: Date;
+    }];
+};
+export interface Processor<TaskKind extends keyof TaskMapping, TaskMapping extends TaskMappingBase> extends EventEmitter<ProcessorEvents<TaskKind, TaskMapping>> {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/build/processors/processor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=processor.js.map

package/build/processors/processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"processor.js","sourceRoot":"","sources":["../../src/processors/processor.ts"],"names":[],"mappings":""}

package/build/processors/simple-processor.d.ts

@@ -0,0 +1,70 @@
+import { EventEmitter } from 'node:stream';
+import type { BackoffStrategy } from '../backoff-strategy';
+import type { TaskMappingBase } from '../chrono';
+import type { Datastore, Task } from '../datastore';
+import type { Processor, ProcessorEvents } from './processor';
+type SimpleProcessorConfig<TaskKind extends keyof TaskMapping, TaskMapping extends TaskMappingBase, DatastoreOptions> = {
+    datastore: Datastore<TaskMapping, DatastoreOptions>;
+    kind: TaskKind;
+    handler: (task: Task<TaskKind, TaskMapping[TaskKind]>) => Promise<void>;
+    maxConcurrency?: number;
+    backoffStrategy: BackoffStrategy;
+    claimIntervalMs?: number;
+    claimStaleTimeoutMs?: number;
+    idleIntervalMs?: number;
+    taskHandlerTimeoutMs?: number;
+    taskHandlerMaxRetries?: number;
+};
+export declare class SimpleProcessor<TaskKind extends Extract<keyof TaskMapping, string>, TaskMapping extends TaskMappingBase, DatastoreOptions> extends EventEmitter<ProcessorEvents<TaskKind, TaskMapping>> implements Processor<TaskKind, TaskMapping> {
+    readonly taskKind: TaskKind;
+    readonly datastore: Datastore<TaskMapping, DatastoreOptions>;
+    readonly handler: (task: Task<TaskKind, TaskMapping[TaskKind]>) => Promise<void>;
+    private maxConcurrency;
+    private backOffStrategy;
+    readonly claimIntervalMs: number;
+    readonly claimStaleTimeoutMs: number;
+    readonly idleIntervalMs: number;
+    readonly taskHandlerTimeoutMs: number;
+    readonly taskHandlerMaxRetries: number;
+    private exitChannels;
+    private stopRequested;
+    constructor(config: SimpleProcessorConfig<TaskKind, TaskMapping, DatastoreOptions>);
+    /**
+     * Validates that the task handler timeout is less than the claim stale timeout.
+     * Throws an error if the validation fails.
+     * This ensures that the task handler has enough time to complete before the task is considered stale.
+     * This is important to prevent tasks from being claimed again while they are still being processed.
+     *
+     * @throws {Error} If the task handler timeout is greater than or equal to the claim stale timeout.
+     */
+    private validatedHandlerTimeout;
+    /**
+     * Starts multiple concurrent process loops that claim and process tasks.
+     * Max concurrent processes is defined by the `maxConcurrency` property set in the constructor.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the processor by signaling all process loops to exit,
+     * then waits for all process loops to finish before resolving.
+     */
+    stop(): Promise<void>;
+    /**
+     * The main loop that processes tasks.
+     *
+     * @param exitChannel The channel to signal when the loop exits.
+     */
+    private runProcessLoop;
+    /**
+     * Handles a task by calling the handler and marking it as complete or failed.
+     *
+     * Emits:
+     * - `task.completed` when the task is successfully completed.
+     * - `task.failed` when the task fails.
+     * - `task.complete.failed` when the task fails to mark as completed.
+     *
+     * @param task The task to handle.
+     */
+    private handleTask;
+    private handleTaskError;
+}
+export {};

package/build/processors/simple-processor.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleProcessor = void 0;
+const node_stream_1 = require("node:stream");
+const promises_1 = require("node:timers/promises");
+const promise_utils_1 = require("../utils/promise-utils");
+const DEFAULT_MAX_CONCURRENCY = 1;
+const DEFAULT_CLAIM_INTERVAL_MS = 50;
+const DEFAULT_CLAIM_STALE_TIMEOUT_MS = 10_000;
+const DEFAULT_IDLE_INTERVAL_MS = 5_000;
+const DEFAULT_TASK_HANDLER_TIMEOUT_MS = 5_000;
+const DEFAULT_TASK_HANDLER_MAX_RETRIES = 10;
+class SimpleProcessor extends node_stream_1.EventEmitter {
+    taskKind;
+    datastore;
+    handler;
+    maxConcurrency;
+    backOffStrategy;
+    claimIntervalMs;
+    claimStaleTimeoutMs;
+    idleIntervalMs;
+    taskHandlerTimeoutMs;
+    taskHandlerMaxRetries;
+    exitChannels = [];
+    stopRequested = false;
+    constructor(config) {
+        super();
+        this.datastore = config.datastore;
+        this.handler = config.handler;
+        this.taskKind = config.kind;
+        this.backOffStrategy = config.backoffStrategy;
+        this.maxConcurrency = config.maxConcurrency || DEFAULT_MAX_CONCURRENCY;
+        this.claimIntervalMs = config.claimIntervalMs || DEFAULT_CLAIM_INTERVAL_MS;
+        this.claimStaleTimeoutMs = config.claimStaleTimeoutMs || DEFAULT_CLAIM_STALE_TIMEOUT_MS;
+        this.idleIntervalMs = config.idleIntervalMs || DEFAULT_IDLE_INTERVAL_MS;
+        this.taskHandlerTimeoutMs = config.taskHandlerTimeoutMs || DEFAULT_TASK_HANDLER_TIMEOUT_MS;
+        this.taskHandlerMaxRetries = config.taskHandlerMaxRetries || DEFAULT_TASK_HANDLER_MAX_RETRIES;
+        this.validatedHandlerTimeout();
+    }
+    /**
+     * Validates that the task handler timeout is less than the claim stale timeout.
+     * Throws an error if the validation fails.
+     * This ensures that the task handler has enough time to complete before the task is considered stale.
+     * This is important to prevent tasks from being claimed again while they are still being processed.
+     *
+     * @throws {Error} If the task handler timeout is greater than or equal to the claim stale timeout.
+     */
+    validatedHandlerTimeout() {
+        if (this.taskHandlerTimeoutMs >= this.claimStaleTimeoutMs) {
+            throw new Error(`Task handler timeout (${this.taskHandlerTimeoutMs}ms) must be less than the claim stale timeout (${this.claimStaleTimeoutMs}ms)`);
+        }
+    }
+    /**
+     * Starts multiple concurrent process loops that claim and process tasks.
+     * Max concurrent processes is defined by the `maxConcurrency` property set in the constructor.
+     */
+    async start() {
+        if (this.stopRequested || this.exitChannels.length > 0) {
+            return;
+        }
+        for (let i = 0; i < this.maxConcurrency; i++) {
+            const exitChannel = new node_stream_1.EventEmitter();
+            this.exitChannels.push(exitChannel);
+            this.runProcessLoop(exitChannel);
+        }
+    }
+    /**
+     * Stops the processor by signaling all process loops to exit,
+     * then waits for all process loops to finish before resolving.
+     */
+    async stop() {
+        const exitPromises = this.exitChannels.map((channel) => new Promise((resolve) => channel.once('processloop.exit', resolve)));
+        this.stopRequested = true;
+        await Promise.all(exitPromises);
+    }
+    /**
+     * The main loop that processes tasks.
+     *
+     * @param exitChannel The channel to signal when the loop exits.
+     */
+    async runProcessLoop(exitChannel) {
+        while (!this.stopRequested) {
+            try {
+                const task = await this.datastore.claim({
+                    kind: this.taskKind,
+                    claimStaleTimeoutMs: this.claimStaleTimeoutMs,
+                });
+                // If no tasks are available, wait before trying again
+                if (!task) {
+                    await (0, promises_1.setTimeout)(this.idleIntervalMs);
+                    continue;
+                }
+                this.emit('task:claimed', { task, timestamp: new Date() });
+                // Process the task using the handler
+                await this.handleTask(task);
+                // Wait a bit before claiming the next task
+                await (0, promises_1.setTimeout)(this.claimIntervalMs);
+            }
+            catch (error) {
+                this.emit('processloop:error', { error: error, timestamp: new Date() });
+            }
+        }
+        exitChannel.emit('processloop:exit');
+    }
+    /**
+     * Handles a task by calling the handler and marking it as complete or failed.
+     *
+     * Emits:
+     * - `task.completed` when the task is successfully completed.
+     * - `task.failed` when the task fails.
+     * - `task.complete.failed` when the task fails to mark as completed.
+     *
+     * @param task The task to handle.
+     */
+    async handleTask(task) {
+        try {
+            await (0, promise_utils_1.promiseWithTimeout)(this.handler(task), this.taskHandlerTimeoutMs);
+        }
+        catch (error) {
+            await this.handleTaskError(task, error);
+            return;
+        }
+        try {
+            const completedTask = await this.datastore.complete(task.id);
+            this.emit('task:completed', {
+                task: completedTask,
+                timestamp: completedTask.completedAt || new Date(),
+            });
+        }
+        catch (error) {
+            this.emit('task:completion:failed', {
+                error: error,
+                task,
+                timestamp: new Date(),
+            });
+        }
+    }
+    async handleTaskError(task, error) {
+        if (task.retryCount >= this.taskHandlerMaxRetries) {
+            // Mark the task as failed
+            await this.datastore.fail(task.id);
+            this.emit('task:failed', {
+                task,
+                error,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const delay = this.backOffStrategy({ retryAttempt: task.retryCount });
+        const nextScheduledAt = new Date(Date.now() + delay);
+        await this.datastore.unclaim(task.id, nextScheduledAt);
+        this.emit('task:unclaimed', {
+            task,
+            error,
+            timestamp: new Date(),
+        });
+    }
+}
+exports.SimpleProcessor = SimpleProcessor;
+//# sourceMappingURL=simple-processor.js.map

package/build/processors/simple-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-processor.js","sourceRoot":"","sources":["../../src/processors/simple-processor.ts"],"names":[],"mappings":"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"}

package/build/scheduler.d.ts

@@ -0,0 +1,9 @@
+export interface Task<T> {
+    run(): Promise<T>;
+}
+export declare class Scheduler<T> {
+    #private;
+    constructor();
+    schedule(task: Task<T>): Promise<boolean>;
+    run(): Promise<boolean>;
+}

package/build/scheduler.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+class Scheduler {
+    #tasks = [];
+    constructor() {
+        this.#tasks = [];
+    }
+    async schedule(task) {
+        this.#tasks.push(task);
+        return true;
+    }
+    async run() {
+        for (const task of this.#tasks) {
+            task.run();
+        }
+        return true;
+    }
+}
+exports.Scheduler = Scheduler;
+//# sourceMappingURL=scheduler.js.map

package/build/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":";;;AAIA,MAAa,SAAS;IACpB,MAAM,GAAc,EAAE,CAAC;IAEvB;QACE,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACnB,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,IAAa;QACjC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEvB,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,KAAK,CAAC,GAAG;QACd,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAC/B,IAAI,CAAC,GAAG,EAAE,CAAC;QACb,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AApBD,8BAoBC"}

package/build/task.d.ts

@@ -0,0 +1,33 @@
+export declare const TaskStatus: {
+    readonly PENDING: "PENDING";
+    readonly CLAIMED: "CLAIMED";
+    readonly COMPLETED: "COMPLETED";
+    readonly FAILED: "FAILED";
+};
+export type TaskStatus = (typeof TaskStatus)[keyof typeof TaskStatus];
+export type Task<TaskKind, TaskData> = {
+    /** A unique identifier for the task */
+    id: string;
+    /** A human-readable name or type for the task */
+    kind: TaskKind;
+    /** The current status of the task */
+    status: TaskStatus;
+    /** The payload or data associated with the task */
+    data: TaskData;
+    /** The priority level of the task (lower numbers can indicate higher priority) */
+    priority?: number;
+    /** A key used for idempotency to prevent duplicate processing */
+    idempotencyKey?: string;
+    /** The original scheduled date when the task was first intended to run */
+    originalScheduleDate: Date;
+    /** The current scheduled execution date, which may change if rescheduled */
+    scheduledAt: Date;
+    /** The date the task is mark 'claimed */
+    claimedAt?: Date;
+    /** The date the task is mark 'completed' */
+    completedAt?: Date;
+    /** The date when the task was last executed (if any) */
+    lastExecutedAt?: Date;
+    /** A counter to track the number of times the task has been retried */
+    retryCount: number;
+};

package/build/task.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStatus = void 0;
+exports.TaskStatus = {
+    PENDING: "PENDING",
+    CLAIMED: "CLAIMED",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+};
+//# sourceMappingURL=task.js.map

package/build/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../src/task.ts"],"names":[],"mappings":";;;AAAa,QAAA,UAAU,GAAG;IACxB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;IACtB,MAAM,EAAE,QAAQ;CACR,CAAC"}

package/build/utils/promise-utils.d.ts

@@ -0,0 +1 @@
+export declare function promiseWithTimeout<T>(promise: Promise<T>, timeout: number): Promise<T>;

package/build/utils/promise-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseWithTimeout = promiseWithTimeout;
+function promiseWithTimeout(promise, timeout) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error('Promise timed out'));
+        }, timeout);
+        promise
+            .then((result) => {
+            clearTimeout(timer);
+            resolve(result);
+        })
+            .catch((error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+//# sourceMappingURL=promise-utils.js.map

package/build/utils/promise-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-utils.js","sourceRoot":"","sources":["../../src/utils/promise-utils.ts"],"names":[],"mappings":";;AAAA,gDAgBC;AAhBD,SAAgB,kBAAkB,CAAI,OAAmB,EAAE,OAAe;IACxE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,CAAC,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC;QACzC,CAAC,EAAE,OAAO,CAAC,CAAC;QAEZ,OAAO;aACJ,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YACf,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,OAAO,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACf,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@neofinancial/chrono",
+  "version": "0.1.0",
+  "description": "",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build/**"
+  ],
+  "keywords": [],
+  "author": "Neo Financial Engineering <engineering@neofinancial.com>",
+  "license": "MIT",
+  "scripts": {
+    "clean": "rimraf ./build",
+    "build": "tsc",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit",
+    "test": "NODE_ENV=test TZ=UTC vitest run"
+  }
+}