@duplojs/utils 1.6.1 → 1.6.2

package/dist/flow/run.mjs

@@ -7,6 +7,12 @@ import { breakKind } from './theFlow/break.mjs';
 import { exitKind } from './theFlow/exit.mjs';
 import { stepKind } from './theFlow/step.mjs';
 import { injectionKind } from './theFlow/injection.mjs';
+import { throttlingKind } from './theFlow/throttling.mjs';
+import { createExternalPromise } from '../common/externalPromise.mjs';
+import { calledByNextKind } from './theFlow/calledByNext.mjs';
+import { queueKind } from './theFlow/queue.mjs';
+import { createQueue } from '../common/queue.mjs';
+import { debounceKind } from './theFlow/debounce.mjs';
 import { justExec } from '../common/justExec.mjs';
 import { kindHeritage } from '../common/kind.mjs';
 
@@ -17,6 +23,18 @@ class MissingDependenceError extends kindHeritage("missing-dependence-error", cr
         this.dependenceHandler = dependenceHandler;
     }
 }
+/** @internal */
+const throttlingLastTimeWeakStore = new WeakMap();
+/** @internal */
+const throttlingResumerWeakStore = new WeakMap();
+/** @internal */
+const debounceTimeoutIdWeakStore = new WeakMap();
+/** @internal */
+const debounceResumerWeakStore = new WeakMap();
+/** @internal */
+const calledByNextFunctionWeakStore = new WeakMap();
+/** @internal */
+const queuesWeakStore = new WeakMap();
 /**
  * {@include flow/run/index.md}
  */
@@ -24,6 +42,10 @@ function run(theFlow, ...[params]) {
     let result = undefined;
     let deferFunctions = undefined;
     let steps = undefined;
+    let alreadyUseThrottling = undefined;
+    let alreadyUseDebounce = undefined;
+    let alreadyUseCalledByNext = undefined;
+    let alreadyUseQueue = undefined;
     const generator = typeof theFlow === "function"
         ? theFlow(params?.input)
         : theFlowKind.getValue(theFlow).run(params?.input);
@@ -65,6 +87,79 @@ function run(theFlow, ...[params]) {
                         }
                         injectionProperties.inject(params.dependencies[dependenceName]);
                     }
+                    else if (throttlingKind.has(result.value)) {
+                        if (alreadyUseThrottling) {
+                            continue;
+                        }
+                        alreadyUseThrottling = true;
+                        const { time, keepLast, returnValue } = throttlingKind.getValue(result.value);
+                        const lastTime = throttlingLastTimeWeakStore.get(theFlow);
+                        const now = Date.now();
+                        throttlingLastTimeWeakStore.set(theFlow, now);
+                        if (typeof lastTime === "number" && (lastTime + time) > now) {
+                            if (keepLast === true) {
+                                const resumer = throttlingResumerWeakStore.get(theFlow);
+                                resumer?.(false);
+                                const externalPromise = createExternalPromise();
+                                throttlingResumerWeakStore.set(theFlow, externalPromise.resolve);
+                                if (await externalPromise.promise) {
+                                    continue;
+                                }
+                            }
+                            result = await generator.return(returnValue);
+                            break;
+                        }
+                        else if (keepLast === true) {
+                            setTimeout(() => {
+                                const resumer = throttlingResumerWeakStore.get(theFlow);
+                                resumer?.(true);
+                            }, time);
+                        }
+                    }
+                    else if (calledByNextKind.has(result.value)) {
+                        if (alreadyUseCalledByNext) {
+                            continue;
+                        }
+                        alreadyUseCalledByNext = calledByNextKind.getValue(result.value);
+                        const lastFunction = calledByNextFunctionWeakStore.get(theFlow);
+                        const lastResult = lastFunction?.();
+                        if (lastResult instanceof Promise) {
+                            await lastResult;
+                        }
+                        calledByNextFunctionWeakStore.set(theFlow, alreadyUseCalledByNext);
+                    }
+                    else if (queueKind.has(result.value)) {
+                        if (alreadyUseQueue) {
+                            continue;
+                        }
+                        const { concurrency, injectResolver } = queueKind.getValue(result.value);
+                        let queue = queuesWeakStore.get(theFlow);
+                        if (queue === undefined) {
+                            queue = createQueue({ concurrency });
+                            queuesWeakStore.set(theFlow, queue);
+                        }
+                        alreadyUseQueue = await queue.addExternal();
+                        injectResolver(alreadyUseQueue);
+                    }
+                    else if (debounceKind.has(result.value)) {
+                        if (alreadyUseDebounce) {
+                            continue;
+                        }
+                        alreadyUseDebounce = true;
+                        const { time, returnValue } = debounceKind.getValue(result.value);
+                        const lastTimeout = debounceTimeoutIdWeakStore.get(theFlow);
+                        clearTimeout(lastTimeout);
+                        const lastResumer = debounceResumerWeakStore.get(theFlow);
+                        lastResumer?.(false);
+                        const externalPromise = createExternalPromise();
+                        debounceTimeoutIdWeakStore.set(theFlow, setTimeout(() => void externalPromise.resolve(true), time));
+                        debounceResumerWeakStore.set(theFlow, externalPromise.resolve);
+                        if (await externalPromise.promise) {
+                            continue;
+                        }
+                        result = await generator.return(returnValue);
+                        break;
+                    }
                 } while (true);
                 return params?.includeDetails === true
                     ? {
@@ -74,6 +169,13 @@ function run(theFlow, ...[params]) {
                     : result.value;
             }
             finally {
+                if (alreadyUseCalledByNext
+                    && calledByNextFunctionWeakStore.get(theFlow) === alreadyUseCalledByNext) {
+                    calledByNextFunctionWeakStore.delete(theFlow);
+                }
+                if (alreadyUseQueue) {
+                    alreadyUseQueue();
+                }
                 await generator.return(undefined);
                 if (deferFunctions) {
                     await Promise.all(deferFunctions.map(justExec));
@@ -117,6 +219,16 @@ function run(theFlow, ...[params]) {
                 }
                 injectionProperties.inject(params.dependencies[dependenceName]);
             }
+            else if (throttlingKind.has(result.value)) {
+                const { time, returnValue } = throttlingKind.getValue(result.value);
+                const lastTime = throttlingLastTimeWeakStore.get(theFlow);
+                const now = Date.now();
+                throttlingLastTimeWeakStore.set(theFlow, now);
+                if (typeof lastTime === "number" && (lastTime + time) > now) {
+                    result = generator.return(returnValue);
+                    break;
+                }
+            }
         } while (true);
         return (params?.includeDetails === true
             ? {
@@ -133,4 +245,4 @@ function run(theFlow, ...[params]) {
     }
 }
 
-export { MissingDependenceError, run };
+export { MissingDependenceError, calledByNextFunctionWeakStore, debounceResumerWeakStore, debounceTimeoutIdWeakStore, queuesWeakStore, run, throttlingLastTimeWeakStore, throttlingResumerWeakStore };

package/dist/flow/theFlow/calledByNext.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const calledByNextKind = kind.createFlowKind("called-by-next");
+function createCalledByNext(value) {
+    return calledByNextKind.setTo({}, value);
+}
+
+exports.calledByNextKind = calledByNextKind;
+exports.createCalledByNext = createCalledByNext;

package/dist/flow/theFlow/calledByNext.d.ts

@@ -0,0 +1,5 @@
+import { type AnyFunction, type Kind } from "../../common";
+export declare const calledByNextKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/called-by-next", AnyFunction<[], unknown>>>;
+export interface CalledByNext<GenericValue extends unknown = unknown> extends Kind<typeof calledByNextKind.definition, () => GenericValue> {
+}
+export declare function createCalledByNext<GenericOutput extends unknown>(value: () => GenericOutput): CalledByNext<GenericOutput>;

package/dist/flow/theFlow/calledByNext.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const calledByNextKind = createFlowKind("called-by-next");
+function createCalledByNext(value) {
+    return calledByNextKind.setTo({}, value);
+}
+
+export { calledByNextKind, createCalledByNext };

package/dist/flow/theFlow/debounce.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const debounceKind = kind.createFlowKind("debounce");
+function createDebounce(properties) {
+    return debounceKind.setTo({}, properties);
+}
+
+exports.createDebounce = createDebounce;
+exports.debounceKind = debounceKind;

package/dist/flow/theFlow/debounce.d.ts

@@ -0,0 +1,9 @@
+import { type Kind } from "../../common";
+export declare const debounceKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/debounce", unknown>>;
+export interface DebounceProperties<GenericValue extends unknown = unknown> {
+    time: number;
+    returnValue: GenericValue;
+}
+export interface Debounce<GenericValue extends unknown = unknown> extends Kind<typeof debounceKind.definition, DebounceProperties<GenericValue>> {
+}
+export declare function createDebounce<GenericValue extends unknown>(properties: DebounceProperties<GenericValue>): Debounce<GenericValue>;

package/dist/flow/theFlow/debounce.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const debounceKind = createFlowKind("debounce");
+function createDebounce(properties) {
+    return debounceKind.setTo({}, properties);
+}
+
+export { createDebounce, debounceKind };

package/dist/flow/theFlow/index.d.ts

@@ -6,6 +6,10 @@ import { type Break } from "./break";
 import { type Defer } from "./defer";
 import { type Finalizer } from "./finalizer";
 import { type DependenceHandler, type dependenceHandlerKind } from "./dependence";
+import { type Throttling } from "./throttling";
+import { type CalledByNext } from "./calledByNext";
+import { type Queue } from "./queue";
+import { type Debounce } from "./debounce";
 export * from "./step";
 export * from "./exit";
 export * from "./break";
@@ -13,8 +17,12 @@ export * from "./injection";
 export * from "./defer";
 export * from "./finalizer";
 export * from "./dependence";
-export type Effect = (Injection | Step | Exit | Break | Defer | Finalizer);
-export type TheFlowGenerator<GenericOutput extends unknown = unknown, GenericEffect extends Effect = Effect> = (Generator<GenericEffect, GenericOutput> | AsyncGenerator<GenericEffect, GenericOutput>);
+export * from "./throttling";
+export * from "./calledByNext";
+export * from "./queue";
+export * from "./debounce";
+export type Effect = (Injection | Step | Exit | Break | Defer | Finalizer | Throttling | CalledByNext | Queue | Debounce);
+export type TheFlowGenerator<GenericOutput extends unknown = unknown, GenericEffect extends Effect = Effect> = (Generator<Exclude<GenericEffect, (Queue | CalledByNext | Debounce)>, GenericOutput> | AsyncGenerator<GenericEffect, GenericOutput>);
 export type TheFlowFunction<GenericInput extends any = any, GenericGenerator extends TheFlowGenerator = TheFlowGenerator> = (input: GenericInput) => GenericGenerator;
 export interface TheFlowProperties<GenericFunction extends TheFlowFunction = TheFlowFunction> {
     run: GenericFunction;
@@ -78,7 +86,7 @@ export interface TheFlow<GenericFunction extends TheFlowFunction = TheFlowFuncti
  */
 export declare function create<GenericTheFlowFunction extends TheFlowFunction>(theFunction: GenericTheFlowFunction): TheFlow<GenericTheFlowFunction>;
 export type FlowInput<GenericFlow extends TheFlow> = GenericFlow extends TheFlow<infer InferredFunction> ? InferredFunction extends TheFlowFunction<infer InferredInput> ? InferredInput : never : never;
-export type WrapFlow<GenericFlow extends (TheFlow | TheFlowFunction | TheFlowGenerator)> = GenericFlow extends TheFlowGenerator ? TheFlow<TheFlowFunction<unknown, GenericFlow>> : GenericFlow extends TheFlowFunction ? TheFlow<GenericFlow> : GenericFlow;
+export type WrapFlow<GenericFlow extends (TheFlow | TheFlowFunction | TheFlowGenerator)> = GenericFlow extends TheFlowGenerator ? TheFlow<TheFlowFunction<unknown, GenericFlow>> : GenericFlow extends TheFlowFunction ? TheFlow<GenericFlow> : Extract<GenericFlow, TheFlow>;
 export type FlowDependencies<GenericFlow extends TheFlow> = (ExtractFlowGenerator<GenericFlow> extends TheFlowGenerator<any, infer InferredEffect> ? InferredEffect extends Injection<infer InferredDependenceHandler> ? InferredDependenceHandler : never : never) extends infer InferredDependenceHandler extends DependenceHandler ? {
     [Dependence in InferredDependenceHandler as Extract<GetKindValue<typeof dependenceHandlerKind, Dependence>, string>]: ReturnType<InferredDependenceHandler>;
 } : never;

package/dist/flow/theFlow/queue.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const queueKind = kind.createFlowKind("queue");
+function createQueue(properties) {
+    return queueKind.setTo({}, properties);
+}
+
+exports.createQueue = createQueue;
+exports.queueKind = queueKind;

package/dist/flow/theFlow/queue.d.ts

@@ -0,0 +1,9 @@
+import { type Kind } from "../../common";
+export declare const queueKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/queue", unknown>>;
+export interface QueueProperties {
+    concurrency: number;
+    injectResolver(resolver: () => void): void;
+}
+export interface Queue extends Kind<typeof queueKind.definition, QueueProperties> {
+}
+export declare function createQueue(properties: QueueProperties): Queue;

package/dist/flow/theFlow/queue.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const queueKind = createFlowKind("queue");
+function createQueue(properties) {
+    return queueKind.setTo({}, properties);
+}
+
+export { createQueue, queueKind };

package/dist/flow/theFlow/throttling.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const throttlingKind = kind.createFlowKind("throttling");
+function createThrottling(properties) {
+    return throttlingKind.setTo({}, properties);
+}
+
+exports.createThrottling = createThrottling;
+exports.throttlingKind = throttlingKind;

package/dist/flow/theFlow/throttling.d.ts

@@ -0,0 +1,10 @@
+import { type Kind } from "../../common";
+export declare const throttlingKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsFlow/throttling", unknown>>;
+export interface ThrottlingProperties<GenericValue extends unknown = unknown> {
+    time: number;
+    returnValue: GenericValue;
+    keepLast: boolean;
+}
+export interface Throttling<GenericValue extends unknown = unknown> extends Kind<typeof throttlingKind.definition, ThrottlingProperties<GenericValue>> {
+}
+export declare function createThrottling<GenericValue extends unknown>(properties: ThrottlingProperties<GenericValue>): Throttling<GenericValue>;

package/dist/flow/theFlow/throttling.mjs

@@ -0,0 +1,8 @@
+import { createFlowKind } from '../kind.mjs';
+
+const throttlingKind = createFlowKind("throttling");
+function createThrottling(properties) {
+    return throttlingKind.setTo({}, properties);
+}
+
+export { createThrottling, throttlingKind };

package/dist/flow/throttling.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var throttling$1 = require('./theFlow/throttling.cjs');
+
+/**
+ * {@include flow/throttling/index.md}
+ */
+function throttling(time, params) {
+    if (params?.keepLast === true) {
+        return (async function* () {
+            yield throttling$1.createThrottling({
+                time,
+                returnValue: params?.returnValue,
+                keepLast: true,
+            });
+        })();
+    }
+    return (function* () {
+        yield throttling$1.createThrottling({
+            time,
+            returnValue: params?.returnValue,
+            keepLast: false,
+        });
+    })();
+}
+
+exports.throttling = throttling;

package/dist/flow/throttling.d.ts

@@ -0,0 +1,60 @@
+import { type OnlyLiteralBoolean, type IsEqual } from "../common";
+import { type Throttling } from "./theFlow";
+/**
+ * Throttles repeated runs of the same flow and can return a fallback value when a run happens too early.
+ * 
+ * **Supported call styles:**
+ * - Classic: `throttling(time)` -> yields a throttling effect
+ * - Classic with options: `throttling(time, params)` -> yields a throttling effect with a fallback return value and optional `keepLast`
+ * 
+ * `throttling` lets the runner decide whether the current run should continue or stop early depending on the previous execution time of the same flow.
+ * When a run happens inside the throttling window, the runner can return `params.returnValue`.
+ * With `keepLast: true`, the runner keeps the last skipped async run and resumes it after the delay.
+ * 
+ * ```ts
+ * const searchFlow = F.create(
+ * 	function *(query: string) {
+ * 		yield *F.throttling(
+ * 			300,
+ * 			{ returnValue: "skipped" as const },
+ * 		);
+ * 		return query;
+ * 	},
+ * );
+ * const runSearch = F.toFunction(searchFlow);
+ * 
+ * runSearch("first"); // "first"
+ * 
+ * runSearch("second"); // "skipped"
+ * 
+ * const latestFlow = F.create(
+ * 	async function *(value: string) {
+ * 		yield *F.throttling(
+ * 			500,
+ * 			{
+ * 				returnValue: "ignored" as const,
+ * 				keepLast: true,
+ * 			},
+ * 		);
+ * 		return Promise.resolve(value);
+ * 	},
+ * );
+ * const runLatestFlow = F.toFunction(latestFlow);
+ * await runLatestFlow("latest"); // Promise<"latest" | "ignored">
+ * ```
+ * 
+ * @remarks
+ * - `keepLast: true` changes the helper to an async generator because the runner may resume the latest skipped run later
+ * - Throttling state is attached to the flow reference, so examples should reuse the same created flow or wrapped function
+ * - If the same flow execution yields `throttling(...)` multiple times, only the first yielded effect is applied by the runner
+ * 
+ * @see [`F.run`](https://utils.duplojs.dev/en/v1/api/flow/run) For the throttling behavior implemented by the runner
+ * @see https://utils.duplojs.dev/en/v1/api/flow/throttling
+ * 
+ * @namespace F
+ * 
+ */
+export declare function throttling<GenericValue extends unknown = undefined, GenericKeepLast extends boolean = false>(time: number, params?: {
+    returnValue?: GenericValue;
+    keepLast?: GenericKeepLast & OnlyLiteralBoolean<GenericKeepLast>;
+}): IsEqual<GenericKeepLast, true> extends true ? AsyncGenerator<Throttling<NoInfer<GenericValue>>, undefined> : Generator<Throttling<NoInfer<GenericValue>>, undefined>;

package/dist/flow/throttling.mjs

@@ -0,0 +1,25 @@
+import { createThrottling } from './theFlow/throttling.mjs';
+
+/**
+ * {@include flow/throttling/index.md}
+ */
+function throttling(time, params) {
+    if (params?.keepLast === true) {
+        return (async function* () {
+            yield createThrottling({
+                time,
+                returnValue: params?.returnValue,
+                keepLast: true,
+            });
+        })();
+    }
+    return (function* () {
+        yield createThrottling({
+            time,
+            returnValue: params?.returnValue,
+            keepLast: false,
+        });
+    })();
+}
+
+export { throttling };

package/dist/flow/toFunction.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var run = require('./run.cjs');
+
+/**
+ * {@include flow/toFunction/index.md}
+ */
+function toFunction(flow, ...[params]) {
+    return (input) => run.run(flow, {
+        ...params,
+        input,
+    });
+}
+
+exports.toFunction = toFunction;

package/dist/flow/toFunction.d.ts

@@ -0,0 +1,56 @@
+import { type SimplifyTopLevel, type IsEqual } from "../common";
+import { type RunResult } from "./run";
+import { type WrapFlow, type TheFlow, type TheFlowFunction, type FlowDependencies, type TheFlowGenerator } from "./theFlow";
+type ComputeToFunctionParams<GenericDependencies extends Record<string, unknown> = Record<string, unknown>> = SimplifyTopLevel<{
+    includeDetails?: boolean;
+} & ({} extends GenericDependencies ? {
+    dependencies?: GenericDependencies;
+} : {
+    dependencies: GenericDependencies;
+})>;
+/**
+ * Converts a flow into a plain callable function that delegates to `F.run(...)`.
+ * 
+ * **Supported call styles:**
+ * - Classic with a flow function: `toFunction(flow, params?)` -> returns a callable function
+ * - Classic with a flow instance: `toFunction(flow, params?)` -> returns a callable function
+ * 
+ * `toFunction` wraps a flow function or a flow created with `F.create(...)` and returns a regular function that accepts only the flow input.
+ * The provided options are forwarded to `F.run(...)`, which means you can preconfigure `includeDetails` and `dependencies`.
+ * Use it when a flow should be exposed as a reusable application function instead of being run manually each time.
+ * 
+ * ```ts
+ * const runUppercase = F.toFunction(
+ * 	function *(input: string) {
+ * 		yield *F.step("uppercase");
+ * 		return input.toUpperCase();
+ * 	},
+ * );
+ * runUppercase("duplo"); // "DUPLO"
+ * 
+ * const runWithDetails = F.toFunction(
+ * 	function *(input: string) {
+ * 		yield *F.step("format");
+ * 		return input.length;
+ * 	},
+ * 	{ includeDetails: true },
+ * );
+ * runWithDetails("hello"); // { result: 5, steps: ["format"] }
+ * 
+ * const service = F.createDependence("service")<string>;
+ * const runWithDependencies = F.toFunction(
+ * 	function *(input: string) {
+ * 		const currentService = yield *F.inject(service);
+ * ```
+ * 
+ * @remarks
+ * - `toFunction` keeps the same sync or async return shape as `F.run(...)` for the wrapped flow
+ * 
+ * @see [`F.run`](https://utils.duplojs.dev/en/v1/api/flow/run) For the execution behavior used internally
+ * @see https://utils.duplojs.dev/en/v1/api/flow/toFunction
+ * 
+ * @namespace F
+ * 
+ */
+export declare function toFunction<GenericInput extends unknown, GenericOutput extends TheFlowGenerator, GenericWrapFlow extends WrapFlow<TheFlowFunction<GenericInput, GenericOutput>>, const GenericParams extends ComputeToFunctionParams<FlowDependencies<GenericWrapFlow>>>(flow: (TheFlowFunction<GenericInput, GenericOutput> | TheFlow<TheFlowFunction<GenericInput, GenericOutput>>), ...[params]: ({} extends GenericParams ? [params?: GenericParams] : [params: GenericParams])): (input: GenericInput) => RunResult<GenericWrapFlow, IsEqual<GenericParams["includeDetails"], true>>;
+export {};

package/dist/flow/toFunction.mjs

@@ -0,0 +1,13 @@
+import { run } from './run.mjs';
+
+/**
+ * {@include flow/toFunction/index.md}
+ */
+function toFunction(flow, ...[params]) {
+    return (input) => run(flow, {
+        ...params,
+        input,
+    });
+}
+
+export { toFunction };

package/dist/index.cjs

@@ -67,6 +67,8 @@ var path = require('./common/path.cjs');
 var transformer = require('./common/transformer.cjs');
 var toRegExp = require('./common/toRegExp.cjs');
 var justExec = require('./common/justExec.cjs');
+var callThen = require('./common/callThen.cjs');
+var queue = require('./common/queue.cjs');
 
 
 
@@ -160,6 +162,7 @@ exports.toCurriedPredicate = toCurriedPredicate.toCurriedPredicate;
 exports.pipeCall = pipeCall.pipeCall;
 exports.AssertsError = asserts.AssertsError;
 exports.asserts = asserts.asserts;
+exports.forwardAsserts = asserts.forwardAsserts;
 Object.defineProperty(exports, "Path", {
 	enumerable: true,
 	get: function () { return path.Path; }
@@ -170,3 +173,6 @@ exports.toNative = transformer.toNative;
 exports.transformer = transformer.transformer;
 exports.toRegExp = toRegExp.toRegExp;
 exports.justExec = justExec.justExec;
+exports.callThen = callThen.callThen;
+exports.createQueue = queue.createQueue;
+exports.queueKind = queue.queueKind;

package/dist/index.mjs

@@ -86,8 +86,10 @@ export { hasSomeKinds } from './common/hasSomeKinds.mjs';
 export { hasKinds } from './common/hasKinds.mjs';
 export { toCurriedPredicate } from './common/toCurriedPredicate.mjs';
 export { pipeCall } from './common/pipeCall.mjs';
-export { AssertsError, asserts } from './common/asserts.mjs';
+export { AssertsError, asserts, forwardAsserts } from './common/asserts.mjs';
 export { Path } from './common/path.mjs';
 export { createTransformer, toJSON, toNative, transformer } from './common/transformer.mjs';
 export { toRegExp } from './common/toRegExp.mjs';
 export { justExec } from './common/justExec.mjs';
+export { callThen } from './common/callThen.mjs';
+export { createQueue, queueKind } from './common/queue.mjs';