kernel-script 1.0.0 → 1.0.1

package/bun.lock

@@ -5,8 +5,6 @@
       "name": "ts-lib-boilerplate",
       "dependencies": {
         "p-queue": "^9.1.2",
-        "sonner": "^2.0.7",
-        "zustand": "^5.0.12",
       },
       "devDependencies": {
         "@types/bun": "latest",
@@ -22,6 +20,7 @@
       },
       "peerDependencies": {
         "react": "^19.2.5",
+        "zustand": "^5.0.12",
       },
     },
   },
@@ -322,22 +321,16 @@
 
     "react": ["react@19.2.5", "", {}, "sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA=="],
 
-    "react-dom": ["react-dom@19.2.5", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.5" } }, "sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag=="],
-
     "readdirp": ["readdirp@5.0.0", "", {}, "sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ=="],
 
     "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
 
-    "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
-
     "semver": ["semver@7.7.4", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="],
 
     "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
 
     "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
 
-    "sonner": ["sonner@2.0.7", "", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w=="],
-
     "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
 
     "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],

package/dist/core/bootstrap/broadcast.d.ts

@@ -0,0 +1,5 @@
+export interface SetupOptions {
+    debug?: boolean;
+    storageKey?: string;
+}
+export declare const createBroadcast: () => (message: any) => void;

package/dist/core/bootstrap/command-handler.d.ts

@@ -0,0 +1,39 @@
+import type { QueueManager } from './../queue-manager';
+export interface CommandPayload {
+    command: string;
+    keycard: string;
+    identifier?: string;
+    payload: {
+        task?: any;
+        tasks?: any[];
+        taskId?: string;
+        taskIds?: string[];
+        taskConfig?: any;
+    };
+}
+export interface CommandHandlerDeps {
+    queueManager: QueueManager;
+    debug: boolean;
+    debugLog: (...args: unknown[]) => void;
+}
+export declare const createCommandHandler: ({ queueManager, debug, debugLog }: CommandHandlerDeps) => (message: CommandPayload) => Promise<import("@/core/queue-manager").QueueStatus | {
+    tasks: import("../types").Task[];
+    status: import("@/core/queue-manager").QueueStatus;
+    async?: undefined;
+    success?: undefined;
+} | {
+    async: boolean;
+    tasks?: undefined;
+    status?: undefined;
+    success?: undefined;
+} | {
+    tasks: import("../types").Task[];
+    status?: undefined;
+    async?: undefined;
+    success?: undefined;
+} | {
+    success: boolean;
+    tasks?: undefined;
+    status?: undefined;
+    async?: undefined;
+} | null>;

package/dist/core/bootstrap/heartbeat.d.ts

@@ -0,0 +1 @@
+export declare const createHeartbeatHandler: () => (count: number) => void;

package/dist/core/bootstrap/index.d.ts

@@ -0,0 +1,6 @@
+import type { BaseEngine } from './../types';
+export interface SetupOptions {
+    debug?: boolean;
+    storageKey?: string;
+}
+export declare const setupBackgroundEngine: (engines: Record<string, BaseEngine>, options?: SetupOptions) => void;

package/dist/core/bootstrap/message-handler.d.ts

@@ -0,0 +1,6 @@
+import type { CommandHandlerDeps } from './command-handler';
+export interface MessageHandlerDeps extends CommandHandlerDeps {
+    broadcast: (message: any) => void;
+    handleHeartbeat: (count: number) => void;
+}
+export declare const createMessageHandler: ({ queueManager, debug, debugLog, broadcast, handleHeartbeat, }: MessageHandlerDeps) => (message: any, _sender: any, sendResponse: (response?: any) => void) => true | undefined;

package/dist/core/bootstrap.d.ts

@@ -1,2 +1,6 @@
 import type { BaseEngine } from './types/engine';
-export declare const setupBackgroundEngine: (engines: Record<string, BaseEngine>) => void;
+export interface SetupOptions {
+    debug?: boolean;
+    storageKey?: string;
+}
+export declare const setupBackgroundEngine: (engines: Record<string, BaseEngine>, options?: SetupOptions) => void;

package/dist/core/engine-hub.d.ts

@@ -1,4 +1,4 @@
-import type { BaseEngine } from './types/engine';
+import type { BaseEngine } from './types';
 export declare class EngineHub {
     private engines;
     register(platformId: string, engine: BaseEngine): void;

package/dist/core/helper.d.ts

@@ -1 +1 @@
-export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+export declare const sleep: (seconds: number, signal?: AbortSignal) => Promise<void>;

package/dist/core/hooks/use-queue.d.ts

@@ -1,10 +1,10 @@
-import type { Task, TaskConfig } from './../types/task';
+import type { Task, TaskConfig } from './../types';
 interface Funcs {
     getTasks: () => Task[];
     setTasks: (tasks: Task[]) => void;
     setPendingCount: (count: number) => void;
-    setIsPaused: (paused: boolean) => void;
-    getIsPaused: () => boolean;
+    setIsRunning: (running: boolean) => void;
+    getIsRunning: () => boolean;
     updateTask: (taskId: string, updates: Partial<Task>) => void;
     deleteTasks: (taskIds: string[]) => void;
     updateTasks: (updates: Record<string, Partial<Task>>) => void;
@@ -15,6 +15,7 @@ export interface QueueHookConfig {
     keycard: string;
     getIdentifier: () => string | undefined;
     funcs: Funcs;
+    debug?: boolean;
 }
 export declare function useQueue(config: QueueHookConfig): () => {
     addTask: (task: Task) => Promise<unknown>;

package/dist/core/persistence-manager.d.ts

@@ -1,9 +1,9 @@
 export interface SerializedQueueState {
-    isPaused: boolean;
     isRunning: boolean;
 }
 export declare class PersistenceManager {
-    private static STORAGE_KEY;
+    private storageKey;
+    constructor(storageKey?: string);
     saveQueueStates(states: Record<string, SerializedQueueState>): Promise<void>;
     loadQueueStates(): Promise<Record<string, SerializedQueueState>>;
 }

package/dist/core/queue/index.d.ts

@@ -0,0 +1,5 @@
+export { TaskExecutor, type TaskExecutorDeps } from './task-executor';
+export { QueuePersistence, type QueuePersistenceDeps } from './persistence';
+export { getQueueManager, type QueueManager, type QueueOptions, type QueueStatus, } from './queue-manager';
+export { TaskContext } from './../task-context';
+export type { Task, TaskConfig, BaseEngine, EngineResult } from './../types';

package/dist/core/queue/persistence.d.ts

@@ -0,0 +1,14 @@
+import { type SerializedQueueState } from './../persistence-manager';
+export interface QueuePersistenceDeps {
+    storageKey?: string;
+}
+export declare class QueuePersistence {
+    private persistenceManager;
+    constructor(deps: QueuePersistenceDeps);
+    saveQueueStates(states: Record<string, SerializedQueueState>): Promise<void>;
+    loadQueueStates(): Promise<Record<string, SerializedQueueState> | null>;
+    parseQueueKey(queueKey: string): {
+        keycard: string;
+        identifier: string;
+    } | null;
+}

package/dist/core/queue/queue-manager.d.ts

@@ -0,0 +1,59 @@
+import type { Task, TaskConfig, BaseEngine, EngineResult } from './../types';
+export interface QueueStatus {
+    size: number;
+    pending: number;
+    isPaused: boolean;
+    isRunning: boolean;
+}
+export interface QueueOptions extends Partial<TaskConfig> {
+    debug?: boolean;
+    storageKey?: string;
+    defaultConcurrency?: number;
+    onTaskStart?: (keycard: string, identifier: string, taskId: string) => void;
+    onTaskComplete?: (keycard: string, identifier: string, taskId: string, result: EngineResult) => void;
+    onQueueEmpty?: (keycard: string, identifier: string) => void;
+    onPendingCountChange?: (keycard: string, identifier: string, count: number) => void;
+    onTasksUpdate?: (keycard: string, identifier: string, tasks: Task[], status: QueueStatus) => void;
+}
+export declare class QueueManager {
+    private defaultOptions;
+    private queues;
+    private platformOptions;
+    private runningQueues;
+    private concurrencyMap;
+    debug: boolean;
+    private taskExecutor;
+    private persistence;
+    constructor(defaultOptions: Partial<QueueOptions>);
+    private createTaskExecutor;
+    private debugLog;
+    private logQueueState;
+    private getQueueKey;
+    registerOptions(keycard: string, options: Partial<QueueOptions>): () => void;
+    unregisterOptions(keycard: string, options: QueueOptions): void;
+    private getOptions;
+    private getOrCreateQueue;
+    setConcurrency(keycard: string, concurrency: number): void;
+    registerEngine(keycard: string, engine: BaseEngine): void;
+    add(keycard: string, identifier: string, task: Task): Promise<void>;
+    addMany(keycard: string, identifier: string, newTasks: Task[]): Promise<void>;
+    start(keycard: string, identifier: string): Promise<void>;
+    stop(keycard: string, identifier: string): Promise<void>;
+    pause(keycard: string, identifier: string): Promise<void>;
+    resume(keycard: string, identifier: string): Promise<void>;
+    clear(keycard: string, identifier: string): Promise<void>;
+    haltTask(keycard: string, identifier: string, taskId: string): Promise<void>;
+    cancelTask(keycard: string, identifier: string, taskId: string): Promise<void>;
+    getStatus(keycard: string, identifier: string): QueueStatus;
+    getTasks(keycard: string, identifier: string): Task[];
+    private updateTasks;
+    private executeTask;
+    private autoStopQueue;
+    private notifyStatusChange;
+    private notifyTasksUpdate;
+    private persistState;
+    updateTaskConfig(keycard: string, identifier: string, taskConfig: TaskConfig): void;
+    hydrate(): Promise<void>;
+    rehydrateTasks(): Promise<void>;
+}
+export declare function getQueueManager(options?: Partial<QueueOptions>): QueueManager;

package/dist/core/queue/queue-state.d.ts

@@ -0,0 +1,13 @@
+import PQueue from 'p-queue';
+import type { TaskConfig } from './../types';
+export interface QueueEntry {
+    queue: PQueue;
+    tasks: any[];
+    queuedIds: Set<string>;
+    consecutiveErrors: number;
+    taskConfig?: TaskConfig;
+}
+export interface QueueStateOptions {
+    defaultConcurrency?: number;
+}
+export declare const createQueueEntry: (concurrency?: number, onIdle?: () => void) => QueueEntry;

package/dist/core/queue/task-executor.d.ts

@@ -0,0 +1,16 @@
+import type { Task, TaskConfig, EngineResult, BaseEngine } from './../types';
+export interface TaskExecutorDeps {
+    getTaskConfig: (keycard: string, identifier: string) => TaskConfig | undefined;
+    getEngine: (keycard: string) => BaseEngine | undefined;
+    persistState: () => Promise<void>;
+    debug: boolean;
+    onTaskStart: (keycard: string, identifier: string, taskId: string) => void;
+    onTaskComplete: (keycard: string, identifier: string, taskId: string, result: EngineResult) => void;
+}
+export declare class TaskExecutor {
+    private deps;
+    private abortControllers;
+    constructor(deps: TaskExecutorDeps);
+    execute(keycard: string, identifier: string, task: Task, tasks: Task[], updateTasks: (tasks: Task[]) => void): Promise<void>;
+    abort(taskId: string): void;
+}

package/dist/core/queue-manager.d.ts

@@ -1,12 +1,13 @@
-import type { Task, TaskConfig } from './types/task';
-import type { BaseEngine, EngineResult } from './types/engine';
+import type { Task, TaskConfig } from './types';
+import type { BaseEngine, EngineResult } from './types';
 export interface QueueStatus {
     size: number;
     pending: number;
-    isPaused: boolean;
     isRunning: boolean;
 }
 export interface QueueOptions {
+    debug?: boolean;
+    storageKey?: string;
     defaultConcurrency?: number;
     onTaskStart?: (keycard: string, identifier: string, taskId: string) => void;
     onTaskComplete?: (keycard: string, identifier: string, taskId: string, result: EngineResult) => void;
@@ -21,7 +22,10 @@ export declare class QueueManager {
     private runningQueues;
     private concurrencyMap;
     private abortControllers;
+    debug: boolean;
+    private persistenceManager;
     constructor(options: Partial<QueueOptions>);
+    private debugLog;
     private logQueueState;
     private getQueueKey;
     registerOptions(keycard: string, options: Partial<QueueOptions>): () => void;
@@ -63,4 +67,4 @@ export declare class QueueManager {
      */
     rehydrateTasks(): Promise<void>;
 }
-export declare function getQueueManager(): QueueManager;
+export declare function getQueueManager(options?: Partial<QueueOptions>): QueueManager;

package/dist/core/registry.d.ts

@@ -1,3 +1,3 @@
-import type { BaseEngine } from './types/engine';
+import type { BaseEngine } from './types';
 import type { QueueManager } from './queue-manager';
 export declare function registerAllEngines(platformEngines: Record<string, BaseEngine>, queueManager: QueueManager): void;

package/dist/core/store/base-task.store.d.ts

@@ -1,17 +1,16 @@
 import { type StateStorage } from 'zustand/middleware';
-import type { Task, TaskConfig } from './../types/task';
+import type { Task, TaskConfig } from './../types';
 export interface TaskStoreState {
     tasks: Task[];
     taskHistory: Task[];
     pendingCount: number;
-    isPaused: boolean;
+    isRunning: boolean;
     selectedIds: string[];
-    generating: boolean;
     taskConfig: TaskConfig;
     getTasks: () => Task[];
     setTasks: (tasks: Task[]) => void;
     setPendingCount: (count: number) => void;
-    setIsPaused: (paused: boolean) => void;
+    setIsRunning: (running: boolean) => void;
     addTask: (task: Task) => void;
     addTasks: (tasks: Task[]) => void;
     updateTask: (taskId: string, updates: Partial<Task>) => void;
@@ -24,9 +23,7 @@ export interface TaskStoreState {
     toggleSelectAll: (ids?: string[]) => void;
     setSelectedIds: (ids: string[]) => void;
     clearSelected: () => void;
-    setGenerating: (generating: boolean) => void;
-    getIsPaused: () => boolean;
-    getGenerating: () => boolean;
+    getIsRunning: () => boolean;
     getTaskConfig: () => TaskConfig;
     updateTaskConfig: (updates: Partial<TaskConfig>) => void;
 }

package/dist/core/task-context.d.ts

@@ -1,4 +1,4 @@
-import type { Task } from './types/task';
+import type { Task } from './types';
 export declare class TaskContext {
     readonly task: Task;
     readonly signal?: AbortSignal;

package/dist/core/types/index.d.ts

@@ -0,0 +1,48 @@
+export type Task = {
+    id: string;
+    no: number;
+    name: string;
+    status: 'Draft' | 'Waiting' | 'Running' | 'Completed' | 'Error' | 'Previous' | 'Skipped';
+    progress: number;
+    payload: Record<string, any>;
+    output?: unknown;
+    errorMessage?: string;
+    isQueued?: boolean;
+    isFlagged?: boolean;
+    createAt?: number;
+    updateAt?: number;
+    [key: string]: unknown;
+};
+export type TaskConfig = {
+    threads: number;
+    delayMin: number;
+    delayMax: number;
+    stopOnErrorCount: number;
+};
+export type QueueStatus = {
+    size: number;
+    pending: number;
+    isRunning: boolean;
+};
+export type QueueOptions = {
+    debug?: boolean;
+    storageKey?: string;
+    defaultConcurrency?: number;
+    onTaskStart?: (keycard: string, identifier: string, taskId: string) => void;
+    onTaskComplete?: (keycard: string, identifier: string, taskId: string, result: EngineResult) => void;
+    onQueueEmpty?: (keycard: string, identifier: string) => void;
+    onPendingCountChange?: (keycard: string, identifier: string, count: number) => void;
+    onTasksUpdate?: (keycard: string, identifier: string, tasks: Task[], status: QueueStatus) => void;
+};
+export type EngineResult = {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+};
+export type BaseEngine = {
+    keycard: string;
+    execute(ctx: any): Promise<EngineResult>;
+};
+export type SerializedQueueState = {
+    isRunning: boolean;
+};