@cetapod/react-native-smb 1.0.0

package/lib/ReactNativeSmb.d.ts

@@ -0,0 +1,200 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { SmbCredentials, NativeSmbTask } from './types';
+/**
+ * A Nitro module that provides SMB client functionality using libsmb2
+ *
+ * This interface provides low-level access to SMB operations with proper
+ * TypeScript typing for React Native applications.
+ */
+export interface ReactNativeSmb extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Checks connection status
+     * @returns True if currently connected to an SMB server
+     */
+    isConnected(): boolean;
+    /**
+     * Checks if the SMB client is initialized
+     * @returns True if initialized, false otherwise
+     */
+    isInitialized(): boolean;
+    /**
+     * Initializes connection to an SMB server (without connecting to a specific share)
+     * @param url Server URL (e.g., "smb://server-ip")
+     * @param credentials Authentication credentials
+     * @returns SmbTask that resolves when initialized
+     */
+    initialize(taskId: string, url: string, credentials: SmbCredentials): NativeSmbTask;
+    /**
+     * Establishes a connection to an SMB server
+     * @param url The SMB server URL (e.g., "smb://server-ip/share")
+     * @param credentials Authentication credentials
+     * @returns SmbTask with connection information
+     * @throws {Error} When connection fails
+     *
+     * @example
+     * await smb.connect('smb://192.168.1.100', {
+     *   username: 'admin',
+     *   password: 'secret'
+     * });
+     */
+    connect(taskId: string, url: string, credentials: SmbCredentials): NativeSmbTask;
+    /**
+     * Connects to a specific share
+     * @param share Name of the share to connect to
+     * @returns SmbTask that resolves when connected
+     * @throws {Error} If not initialized or share doesn't exist
+     */
+    connectShare(taskId: string, share: string): NativeSmbTask;
+    /**
+     * Disconnects from the current SMB server
+     * @returns SmbTask that resolves when disconnected
+     */
+    disconnect(taskId: string): NativeSmbTask;
+    /**
+     * Lists available shares on the server
+     * @returns SmbTask resolving to array of share information
+     * @throws {Error} If not initialized
+     *
+     * @example
+     * const shares = await smb.listShares();
+     * shares.forEach(share => console.log(share.name));
+     */
+    listShares(taskId: string): NativeSmbTask;
+    /**
+     * Lists contents of a directory
+     * @param path Directory path (use "/" for root)
+     * @param recursive Whether to list recursively (default: false)
+     * @param maxDepth Maximum recursion depth (-1 = unlimited, 0 = current only)
+     * @param taskId Unique ID for the task
+     * @param onStatusChange Callback for status updates
+     * @param onProgress Callback for progress updates
+     * @returns SmbTask resolving to array of file/directory info
+     */
+    listDirectory(taskId: string, path: string, recursive: boolean, maxDepth: number): NativeSmbTask;
+    /**
+     * Gets detailed information about a path (file or directory).
+     * Generic version that handles both file/directory types.
+     * @param path Path to the item
+     * @param taskId Unique ID for the task
+     * @param onStatusChange Callback for status updates
+     * @param onProgress Callback for progress updates
+     * @returns SmbTask resolving to file information
+     */
+    getPathInfo(taskId: string, path: string): NativeSmbTask;
+    /**
+     * Retrieves security descriptor for a file/directory
+     * @param path Path to the item
+     * @param taskId Unique ID for the task
+     * @returns SmbTask resolving to security descriptor
+     *
+     * @example
+     * const security = await smb.getSecurityDescriptor('/important.txt');
+     * console.log('Owner:', security.ownerSid);
+     */
+    getSecurityDescriptor(taskId: string, path: string): NativeSmbTask;
+    downloadFile(taskId: string, remotePath: string, localPath: string): NativeSmbTask;
+    /**
+     * Uploads a file from local storage to the SMB server
+     * @param localPath Local path to the file
+     * @param remotePath Destination path on the server
+     * @param progressHandler Optional callback to track upload progress
+     * @returns SmbTask that resolves when upload completes
+     */
+    uploadFile(taskId: string, localPath: string, remotePath: string): NativeSmbTask;
+    /**
+     * Creates a new directory
+     * @param path Path of the directory to create
+     * @returns SmbTask that resolves when directory is created
+     */
+    createDirectory(taskId: string, path: string): NativeSmbTask;
+    /**
+     * Deletes a file or directory (automatically handles recursive deletion)
+     * @param path Path to the item to delete
+     * @returns SmbTask that resolves when deletion completes
+     */
+    deleteItem(taskId: string, path: string): NativeSmbTask;
+    /**
+     * Moves or renames a file/directory
+     * @param fromPath Current path
+     * @param toPath New path
+     * @returns SmbTask that resolves when move completes
+     */
+    moveItem(taskId: string, fromPath: string, toPath: string): NativeSmbTask;
+    /**
+     * Renames a file/directory (in the same directory)
+     * @param currentPath Current path
+     * @param newName New name (without path)
+     * @returns SmbTask that resolves when rename completes
+     */
+    renameItem(taskId: string, currentPath: string, newName: string): NativeSmbTask;
+    /**
+     * Copies a file or directory on the SMB server
+     * @param fromPath Source path
+     * @param toPath Destination path
+     * @param recursive Whether to copy recursively
+     * @param taskId Unique ID for the task
+     * @param onStatusChange Callback for status updates
+     * @param onProgress Callback for progress updates
+     */
+    copyItem(taskId: string, fromPath: string, toPath: string, recursive: boolean): NativeSmbTask;
+    /**
+     * Duplicates an item giving it a unique name
+     * @param path Path to the item
+     * @returns SmbTask resolving to the new path
+     */
+    duplicateItem(taskId: string, path: string): NativeSmbTask;
+    /**
+     * Subscribe to task events (created, status, progress, settled, removed)
+     * @param listener Callback that receives task events
+     * @returns Subscription ID for unsubscribing
+     */
+    subscribeTaskEvents(listener: (event: Record<string, string>) => void): string;
+    /**
+     * Unsubscribe from task events
+     * @param subscriptionId The subscription ID returned from subscribeTaskEvents
+     */
+    unsubscribeTaskEvents(subscriptionId: string): void;
+    /**
+     * Get a specific task snapshot by ID
+     * @param taskId The task ID to retrieve
+     * @returns Task snapshot as string-keyed map, or {exists: '0'} if not found
+     */
+    getTask(taskId: string): Record<string, string>;
+    /**
+     * Get all currently active (pending/running) tasks
+     * @returns Array of task snapshots
+     */
+    getActiveTasks(): Array<Record<string, string>>;
+    /**
+     * Get task history (settled tasks)
+     * @param limit Maximum number of tasks to return
+     * @param offset Number of tasks to skip
+     * @returns Array of task snapshots
+     */
+    getTaskHistory(limit: number, offset: number): Array<Record<string, string>>;
+    /**
+     * Cancels a specific task by ID
+     */
+    cancelTask(taskId: string): void;
+    /**
+     * Clear task history
+     * @param beforeTs Clear tasks that ended before this timestamp (0 = clear all)
+     */
+    clearTaskHistory(beforeTs: bigint): void;
+    subscribePoolInfo(listener: (snapshot: Array<{
+        [key: string]: string;
+    }>) => void): string;
+    unsubscribePoolInfo(subscriptionId: string): void;
+    getPoolInfo(): Array<{
+        [key: string]: string;
+    }>;
+    /**
+     * Force-disconnects every connection-pool slot and forgets cached config.
+     * Use for recovery when slots become stuck (`isConnected:false` but
+     * `inUse:true`). Subsequent operations must re-connect from scratch.
+     */
+    resetPool(): void;
+}

package/lib/ReactNativeSmb.js

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

package/lib/bridge/decode.d.ts

@@ -0,0 +1,4 @@
+import { TaskStatus, type PoolInfo, type SmbTaskState } from '../types';
+export declare function shapeTaskSnapshot(raw: Record<string, string>): SmbTaskState | null;
+export declare function shapePoolInfo(raw: Array<Record<string, string>>): PoolInfo;
+export declare function terminalStatus(raw: Record<string, string>): TaskStatus | null;

package/lib/bridge/decode.js

@@ -0,0 +1,92 @@
+import { SmbOperatorKind, SlotState, TaskStatus, } from '../types';
+function parseIntField(raw, key) {
+    const v = raw[key];
+    if (v === undefined || v === '') {
+        throw new Error(`Missing bridge field: ${key}`);
+    }
+    const n = parseInt(v, 10);
+    if (!Number.isFinite(n)) {
+        throw new Error(`Invalid bridge field ${key}: ${v}`);
+    }
+    return n;
+}
+function parseIntOptional(raw, key, fallback = 0) {
+    const v = raw[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+function parseFloatField(raw, key, fallback = 0) {
+    const v = raw[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const n = parseFloat(v);
+    return Number.isFinite(n) ? n : fallback;
+}
+function parseBoolField(raw, key) {
+    const v = raw[key];
+    return v === '1' || v === 'true';
+}
+function enumFromInt(value, enumObj) {
+    const valid = Object.values(enumObj).filter((v) => typeof v === 'number');
+    if (valid.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid enum value: ${value}`);
+}
+export function shapeTaskSnapshot(raw) {
+    if (raw.exists === '0')
+        return null;
+    const kind = enumFromInt(parseIntField(raw, 'kind'), SmbOperatorKind);
+    const status = enumFromInt(parseIntField(raw, 'status'), TaskStatus);
+    return {
+        taskId: raw.taskId ?? '',
+        kind,
+        status,
+        determinate: parseBoolField(raw, 'determinate'),
+        progress: parseFloatField(raw, 'progress'),
+        bytesDone: parseIntOptional(raw, 'bytesDone'),
+        totalBytes: parseIntOptional(raw, 'totalBytes'),
+        bytesPerSecond: parseFloatField(raw, 'bytesPerSecond'),
+        etaSeconds: parseFloatField(raw, 'etaSeconds'),
+        sourcePath: raw.sourcePath ?? '',
+        destinationPath: raw.destinationPath ?? '',
+        errorCode: parseIntOptional(raw, 'errorCode'),
+        errorMessage: raw.errorMessage ?? '',
+        startedAt: parseIntOptional(raw, 'startedAt'),
+        updatedAt: parseIntOptional(raw, 'updatedAt'),
+        endedAt: parseIntOptional(raw, 'endedAt'),
+    };
+}
+function shapePoolSlot(raw) {
+    return {
+        index: parseIntField(raw, 'index'),
+        interactiveOnly: parseBoolField(raw, 'interactiveOnly'),
+        state: enumFromInt(parseIntField(raw, 'state'), SlotState),
+        isConnected: parseBoolField(raw, 'isConnected'),
+        shareName: raw.shareName ?? '',
+        taskId: raw.taskId ?? '',
+        kind: enumFromInt(parseIntField(raw, 'kind'), SmbOperatorKind),
+    };
+}
+export function shapePoolInfo(raw) {
+    if (!raw || raw.length === 0)
+        return { poolSize: 0, slots: [] };
+    const poolSize = parseIntField(raw[0], 'poolSize');
+    return {
+        poolSize,
+        slots: raw.map(shapePoolSlot),
+    };
+}
+export function terminalStatus(raw) {
+    if (raw.exists === '0')
+        return null;
+    const status = enumFromInt(parseIntField(raw, 'status'), TaskStatus);
+    if (status === TaskStatus.Success ||
+        status === TaskStatus.Error ||
+        status === TaskStatus.Cancelled) {
+        return status;
+    }
+    return null;
+}

package/lib/core/SMB.d.ts

@@ -0,0 +1,3 @@
+import { SmbClient } from './SmbClient';
+export declare function SMB(): SmbClient;
+export type Smb = SmbClient;

package/lib/core/SMB.js

@@ -0,0 +1,4 @@
+import { SmbClient } from './SmbClient';
+export function SMB() {
+    return new SmbClient();
+}

package/lib/core/SmbClient.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNativeSmb } from '../ReactNativeSmb';
+import type { PoolInfo, SmbConnectionInfo, SmbCredentials, SmbFileInfo, SmbSecurityDescriptor, SmbShareList } from '../types';
+import { SmbTask } from './SmbTask';
+import { TransferStore } from './TransferStore';
+export declare class SmbClient {
+    private readonly native;
+    private transfers_?;
+    constructor(native?: ReactNativeSmb);
+    private op;
+    transferStore(): TransferStore;
+    dispose(): void;
+    isConnected(): boolean;
+    isInitialized(): boolean;
+    initialize(url: string, creds: SmbCredentials): SmbTask<void>;
+    connect(url: string, creds: SmbCredentials): SmbTask<SmbConnectionInfo>;
+    connectShare(share: string): SmbTask<SmbConnectionInfo>;
+    disconnect(): SmbTask<void>;
+    listShares(): SmbTask<SmbShareList[]>;
+    listDirectory(path: string, recursive?: boolean, maxDepth?: number): SmbTask<SmbFileInfo[]>;
+    getPathInfo(path: string): SmbTask<SmbFileInfo>;
+    getSecurityDescriptor(path: string): SmbTask<SmbSecurityDescriptor>;
+    downloadFile(remotePath: string, localPath: string): SmbTask<void>;
+    uploadFile(localPath: string, remotePath: string): SmbTask<void>;
+    createDirectory(path: string): SmbTask<void>;
+    deleteItem(path: string): SmbTask<void>;
+    moveItem(from: string, to: string): SmbTask<void>;
+    renameItem(path: string, newName: string): SmbTask<void>;
+    copyItem(from: string, to: string, recursive?: boolean): SmbTask<void>;
+    duplicateItem(path: string): SmbTask<string>;
+    cancelTask(taskId: string): void;
+    getPoolInfo(): PoolInfo;
+    subscribePoolInfo(cb: (info: PoolInfo) => void): string;
+    unsubscribePoolInfo(id: string | null): void;
+    resetPool(): void;
+}

package/lib/core/SmbClient.js

@@ -0,0 +1,99 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { shapePoolInfo } from '../bridge/decode';
+import { generateTaskId } from './ids';
+import { SmbTask } from './SmbTask';
+import { TransferStore } from './TransferStore';
+export class SmbClient {
+    constructor(native) {
+        this.native =
+            native ?? NitroModules.createHybridObject('ReactNativeSmb');
+    }
+    op(call) {
+        const id = generateTaskId();
+        return new SmbTask(id, call(id));
+    }
+    transferStore() {
+        if (!this.transfers_) {
+            this.transfers_ = new TransferStore(this.native);
+        }
+        return this.transfers_;
+    }
+    dispose() {
+        this.transfers_?.stop();
+        this.transfers_ = undefined;
+    }
+    isConnected() {
+        return this.native.isConnected();
+    }
+    isInitialized() {
+        return this.native.isInitialized();
+    }
+    initialize(url, creds) {
+        return this.op((id) => this.native.initialize(id, url, creds));
+    }
+    connect(url, creds) {
+        return this.op((id) => this.native.connect(id, url, creds));
+    }
+    connectShare(share) {
+        return this.op((id) => this.native.connectShare(id, share));
+    }
+    disconnect() {
+        return this.op((id) => this.native.disconnect(id));
+    }
+    listShares() {
+        return this.op((id) => this.native.listShares(id));
+    }
+    listDirectory(path, recursive = false, maxDepth = -1) {
+        return this.op((id) => this.native.listDirectory(id, path, recursive, maxDepth));
+    }
+    getPathInfo(path) {
+        return this.op((id) => this.native.getPathInfo(id, path));
+    }
+    getSecurityDescriptor(path) {
+        return this.op((id) => this.native.getSecurityDescriptor(id, path));
+    }
+    downloadFile(remotePath, localPath) {
+        return this.op((id) => this.native.downloadFile(id, remotePath, localPath));
+    }
+    uploadFile(localPath, remotePath) {
+        return this.op((id) => this.native.uploadFile(id, localPath, remotePath));
+    }
+    createDirectory(path) {
+        return this.op((id) => this.native.createDirectory(id, path));
+    }
+    deleteItem(path) {
+        return this.op((id) => this.native.deleteItem(id, path));
+    }
+    moveItem(from, to) {
+        return this.op((id) => this.native.moveItem(id, from, to));
+    }
+    renameItem(path, newName) {
+        return this.op((id) => this.native.renameItem(id, path, newName));
+    }
+    copyItem(from, to, recursive = false) {
+        return this.op((id) => this.native.copyItem(id, from, to, recursive));
+    }
+    duplicateItem(path) {
+        return this.op((id) => this.native.duplicateItem(id, path));
+    }
+    cancelTask(taskId) {
+        this.native.cancelTask(taskId);
+    }
+    getPoolInfo() {
+        return shapePoolInfo(this.native.getPoolInfo());
+    }
+    subscribePoolInfo(cb) {
+        const id = this.native.subscribePoolInfo((raw) => {
+            cb(shapePoolInfo(raw));
+        });
+        cb(this.getPoolInfo());
+        return id;
+    }
+    unsubscribePoolInfo(id) {
+        if (id)
+            this.native.unsubscribePoolInfo(id);
+    }
+    resetPool() {
+        this.native.resetPool();
+    }
+}

package/lib/core/SmbTask.d.ts

@@ -0,0 +1,41 @@
+import { TaskStatus, type NativeSmbTask, type SmbTaskState } from '../types';
+/**
+ * Handle for one native async operation.
+ *
+ * Creating a task does not subscribe. Three optional actions:
+ * - {@link subscribe} — live progress / status
+ * - {@link result} — await completion and get the typed value
+ * - {@link cancel} — abort
+ */
+export declare class SmbTask<T = void> {
+    private readonly native;
+    readonly id: string;
+    private snapshot_;
+    constructor(id: string, native: NativeSmbTask);
+    /** 0–1 after {@link subscribe} has been called. */
+    get progress(): number;
+    /** Latest status after {@link subscribe}, or a one-shot read via {@link get}. */
+    get status(): TaskStatus;
+    cancel(): void;
+    /** One-shot snapshot without subscribing. */
+    get(): SmbTaskState | null;
+    /**
+     * Subscribe to live updates. Optional — call only when you need progress UI.
+     * Returns unsubscribe. Updates {@link progress} and {@link status} getters.
+     */
+    subscribe(listener?: (snapshot: SmbTaskState) => void): () => void;
+    /**
+     * Await the typed result. Subscribes only when called — not at task creation.
+     *
+     * @example
+     * const task = smb.listDirectory('/', false, -1);
+     * const files = await task.result();
+     */
+    result(): Promise<T>;
+    /** Like `Promise.allSettled` over {@link result}. */
+    static settleAll<T>(tasks: SmbTask<T>[]): Promise<PromiseSettledResult<T>[]>;
+    /** @internal */
+    getRaw(): Record<string, string>;
+    /** @internal */
+    getResultValue(): T;
+}

package/lib/core/SmbTask.js

@@ -0,0 +1,74 @@
+import { shapeTaskSnapshot } from '../bridge/decode';
+import { TaskStatus } from '../types';
+import { taskResult } from './taskResult';
+/**
+ * Handle for one native async operation.
+ *
+ * Creating a task does not subscribe. Three optional actions:
+ * - {@link subscribe} — live progress / status
+ * - {@link result} — await completion and get the typed value
+ * - {@link cancel} — abort
+ */
+export class SmbTask {
+    constructor(id, native) {
+        this.native = native;
+        this.snapshot_ = null;
+        this.id = id;
+    }
+    /** 0–1 after {@link subscribe} has been called. */
+    get progress() {
+        return this.snapshot_?.progress ?? this.get()?.progress ?? 0;
+    }
+    /** Latest status after {@link subscribe}, or a one-shot read via {@link get}. */
+    get status() {
+        return this.snapshot_?.status ?? this.get()?.status ?? TaskStatus.Pending;
+    }
+    cancel() {
+        this.native.cancel();
+    }
+    /** One-shot snapshot without subscribing. */
+    get() {
+        return shapeTaskSnapshot(this.native.get());
+    }
+    /**
+     * Subscribe to live updates. Optional — call only when you need progress UI.
+     * Returns unsubscribe. Updates {@link progress} and {@link status} getters.
+     */
+    subscribe(listener) {
+        const subId = this.native.subscribe((raw) => {
+            const snap = shapeTaskSnapshot(raw);
+            if (!snap)
+                return;
+            this.snapshot_ = snap;
+            listener?.(snap);
+        });
+        const initial = this.get();
+        if (initial) {
+            this.snapshot_ = initial;
+            listener?.(initial);
+        }
+        return () => this.native.unsubscribe(subId);
+    }
+    /**
+     * Await the typed result. Subscribes only when called — not at task creation.
+     *
+     * @example
+     * const task = smb.listDirectory('/', false, -1);
+     * const files = await task.result();
+     */
+    result() {
+        return taskResult(this);
+    }
+    /** Like `Promise.allSettled` over {@link result}. */
+    static settleAll(tasks) {
+        return Promise.allSettled(tasks.map((task) => task.result()));
+    }
+    /** @internal */
+    getRaw() {
+        return this.native.get();
+    }
+    /** @internal */
+    getResultValue() {
+        return this.native.getResultValue();
+    }
+}

package/lib/core/TransferStore.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNativeSmb } from '../ReactNativeSmb';
+import { type SmbTaskState } from '../types';
+type Listener = () => void;
+export declare class TransferStore {
+    private readonly native;
+    private tasks;
+    private hidden;
+    private listeners;
+    private subId;
+    private started;
+    private snapshot;
+    constructor(native: ReactNativeSmb);
+    start(): void;
+    stop(): void;
+    subscribe(listener: Listener): () => void;
+    getSnapshot(): SmbTaskState[];
+    private rebuildSnapshot;
+    clearCompleted(): void;
+    hide(taskId: string): void;
+    private notify;
+}
+export {};

package/lib/core/TransferStore.js

@@ -0,0 +1,88 @@
+import { shapeTaskSnapshot } from '../bridge/decode';
+import { isTransferKind } from '../labels';
+import { TaskStatus } from '../types';
+const EMPTY_SNAPSHOT = [];
+export class TransferStore {
+    constructor(native) {
+        this.native = native;
+        this.tasks = new Map();
+        this.hidden = new Set();
+        this.listeners = new Set();
+        this.subId = null;
+        this.started = false;
+        this.snapshot = EMPTY_SNAPSHOT;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        for (const raw of this.native.getActiveTasks()) {
+            const snap = shapeTaskSnapshot(raw);
+            if (snap && isTransferKind(snap.kind)) {
+                this.tasks.set(snap.taskId, snap);
+            }
+        }
+        this.rebuildSnapshot();
+        this.subId = this.native.subscribeTaskEvents((raw) => {
+            try {
+                const snap = shapeTaskSnapshot(raw);
+                if (!snap || !isTransferKind(snap.kind))
+                    return;
+                if (this.hidden.has(snap.taskId))
+                    return;
+                this.tasks.set(snap.taskId, snap);
+                this.notify();
+            }
+            catch { }
+        });
+    }
+    stop() {
+        if (this.subId) {
+            this.native.unsubscribeTaskEvents(this.subId);
+            this.subId = null;
+        }
+        this.started = false;
+    }
+    subscribe(listener) {
+        this.start();
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getSnapshot() {
+        this.start();
+        return this.snapshot;
+    }
+    rebuildSnapshot() {
+        if (this.tasks.size === 0) {
+            this.snapshot = EMPTY_SNAPSHOT;
+            return;
+        }
+        this.snapshot = Array.from(this.tasks.values())
+            .filter((t) => !this.hidden.has(t.taskId))
+            .sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    clearCompleted() {
+        for (const [id, snap] of this.tasks) {
+            if (snap.status === TaskStatus.Success ||
+                snap.status === TaskStatus.Error ||
+                snap.status === TaskStatus.Cancelled) {
+                this.tasks.delete(id);
+            }
+        }
+        this.notify();
+    }
+    hide(taskId) {
+        this.hidden.add(taskId);
+        this.tasks.delete(taskId);
+        this.notify();
+    }
+    notify() {
+        this.rebuildSnapshot();
+        this.listeners.forEach((l) => {
+            try {
+                l();
+            }
+            catch { }
+        });
+    }
+}

package/lib/core/ids.d.ts

@@ -0,0 +1 @@
+export declare function generateTaskId(): string;

package/lib/core/ids.js

@@ -0,0 +1,3 @@
+export function generateTaskId() {
+    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}