@actuallab/core 12.1.62

package/dist/index.cjs

@@ -0,0 +1,406 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AsyncContext: () => AsyncContext,
+  AsyncContextKey: () => AsyncContextKey,
+  AsyncLock: () => AsyncLock,
+  DisposableBag: () => DisposableBag,
+  EventHandlerSet: () => EventHandlerSet,
+  PromiseSource: () => PromiseSource,
+  Result: () => Result,
+  RetryDelayLimitExceeded: () => RetryDelayLimitExceeded,
+  RetryDelayNone: () => RetryDelayNone,
+  RetryDelaySeq: () => RetryDelaySeq,
+  RetryDelayer: () => RetryDelayer,
+  abortSignalKey: () => abortSignalKey,
+  errorResult: () => errorResult,
+  resolvedVoidPromise: () => resolvedVoidPromise,
+  result: () => result,
+  resultFrom: () => resultFrom,
+  resultFromAsync: () => resultFromAsync
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/polyfills.ts
+Symbol.metadata ??= /* @__PURE__ */ Symbol("Symbol.metadata");
+
+// src/async-context.ts
+var AsyncContextKey = class {
+  id;
+  defaultValue;
+  constructor(name, defaultValue) {
+    this.id = Symbol(name);
+    this.defaultValue = defaultValue;
+  }
+};
+var abortSignalKey = new AsyncContextKey("AbortSignal", void 0);
+var AsyncContext = class _AsyncContext {
+  static current = void 0;
+  /** Immutable empty singleton — avoids allocating new AsyncContext(). */
+  static empty = new _AsyncContext();
+  static _defaults = /* @__PURE__ */ new Map();
+  _values;
+  constructor(values) {
+    this._values = values ?? /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (this._values.has(key.id)) return this._values.get(key.id);
+    if (_AsyncContext._defaults.has(key.id)) return _AsyncContext._defaults.get(key.id);
+    return key.defaultValue;
+  }
+  with(key, value) {
+    const copy = new Map(this._values);
+    copy.set(key.id, value);
+    return new _AsyncContext(copy);
+  }
+  activate() {
+    const prev = _AsyncContext.current;
+    _AsyncContext.current = this;
+    return { dispose: () => {
+      _AsyncContext.current = prev;
+    } };
+  }
+  run(fn) {
+    const prev = _AsyncContext.current;
+    _AsyncContext.current = this;
+    try {
+      return fn();
+    } finally {
+      _AsyncContext.current = prev;
+    }
+  }
+  /** Strip THIS exact instance from args if it's the last element (reference equality). */
+  stripFromArgs(args) {
+    return args[args.length - 1] === this ? args.slice(0, -1) : args;
+  }
+  /** Resolve: return ctx if provided, otherwise AsyncContext.current. */
+  static from(ctx) {
+    return ctx ?? _AsyncContext.current;
+  }
+  /** Extract AsyncContext from last arg if instanceof AsyncContext, else fall back to .current. */
+  static fromArgs(args) {
+    const last = args[args.length - 1];
+    return last instanceof _AsyncContext ? last : _AsyncContext.current;
+  }
+  static setDefault(key, value) {
+    _AsyncContext._defaults.set(key.id, value);
+  }
+  static getOrCreate() {
+    return _AsyncContext.current ?? _AsyncContext.empty;
+  }
+};
+
+// src/async-lock.ts
+var AsyncLock = class {
+  _queue = [];
+  _locked = false;
+  get isLocked() {
+    return this._locked;
+  }
+  async acquire() {
+    if (!this._locked) {
+      this._locked = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this._queue.push(resolve);
+    });
+  }
+  release() {
+    if (!this._locked)
+      throw new Error("AsyncLock is not locked.");
+    const next = this._queue.shift();
+    if (next !== void 0) {
+      next();
+    } else {
+      this._locked = false;
+    }
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+};
+
+// src/disposable.ts
+var DisposableBag = class {
+  _items = [];
+  _disposed = false;
+  get isDisposed() {
+    return this._disposed;
+  }
+  add(item) {
+    if (this._disposed)
+      throw new Error("DisposableBag is already disposed.");
+    this._items.push(item);
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    const items = this._items;
+    this._items = [];
+    for (let i = items.length - 1; i >= 0; i--) {
+      const item = items[i];
+      if (item != null && "dispose" in item) item.dispose();
+    }
+  }
+  async disposeAsync() {
+    if (this._disposed) return;
+    this._disposed = true;
+    const items = this._items;
+    this._items = [];
+    for (let i = items.length - 1; i >= 0; i--) {
+      const item = items[i];
+      if (item == null) continue;
+      if ("disposeAsync" in item) await item.disposeAsync();
+      else if ("dispose" in item) item.dispose();
+    }
+  }
+};
+
+// src/promise-source.ts
+var PromiseSource = class {
+  promise;
+  _resolve;
+  _reject;
+  _isCompleted = false;
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get isCompleted() {
+    return this._isCompleted;
+  }
+  resolve(value) {
+    if (this._isCompleted) return false;
+    this._isCompleted = true;
+    this._resolve(value);
+    return true;
+  }
+  reject(reason) {
+    if (this._isCompleted) return false;
+    this._isCompleted = true;
+    this._reject(reason);
+    return true;
+  }
+};
+var resolvedVoidPromise = Promise.resolve();
+
+// src/events.ts
+var EventHandlerSet = class {
+  _handlers = /* @__PURE__ */ new Set();
+  get count() {
+    return this._handlers.size;
+  }
+  add(handler) {
+    this._handlers.add(handler);
+  }
+  remove(handler) {
+    this._handlers.delete(handler);
+  }
+  trigger(arg) {
+    for (const handler of this._handlers) handler(arg);
+  }
+  clear() {
+    this._handlers.clear();
+  }
+  whenNext() {
+    const ps = new PromiseSource();
+    const handler = (arg) => {
+      this._handlers.delete(handler);
+      ps.resolve(arg);
+    };
+    this._handlers.add(handler);
+    return ps.promise;
+  }
+};
+
+// src/result.ts
+var Result = class _Result {
+  hasValue;
+  hasError;
+  _value;
+  _error;
+  constructor(value, error) {
+    this.hasValue = error === void 0;
+    this.hasError = !this.hasValue;
+    this._value = value;
+    this._error = error;
+  }
+  get value() {
+    if (this.hasError) throw this._error;
+    return this._value;
+  }
+  get error() {
+    return this._error;
+  }
+  get valueOrUndefined() {
+    return this.hasValue ? this._value : void 0;
+  }
+  static ok(value) {
+    return new _Result(value);
+  }
+  static error(error) {
+    return new _Result(void 0, error);
+  }
+};
+function result(value, error) {
+  return new Result(value, error);
+}
+function errorResult(error) {
+  return Result.error(error);
+}
+function resultFrom(fn) {
+  try {
+    return result(fn());
+  } catch (e) {
+    return errorResult(e);
+  }
+}
+async function resultFromAsync(fn) {
+  try {
+    return result(await fn());
+  } catch (e) {
+    return errorResult(e);
+  }
+}
+
+// src/retry-delay-seq.ts
+var DefaultSpread = 0.1;
+var DefaultMultiplier = 1.41421356237;
+function applySpread(origin, spread) {
+  if (spread <= 0) return origin;
+  const delta = origin * spread;
+  return origin + (Math.random() * 2 - 1) * delta;
+}
+var RetryDelaySeq = class _RetryDelaySeq {
+  min;
+  max;
+  spread;
+  multiplier;
+  constructor(min, max, spread = DefaultSpread, multiplier = DefaultMultiplier) {
+    this.min = min;
+    this.max = max;
+    this.spread = spread;
+    this.multiplier = multiplier;
+  }
+  static fixed(delayMs, spread = DefaultSpread) {
+    return new _RetryDelaySeq(delayMs, delayMs, spread, 1);
+  }
+  static exp(minMs, maxMs, spread = DefaultSpread, multiplier = DefaultMultiplier) {
+    return new _RetryDelaySeq(minMs, maxMs, spread, multiplier);
+  }
+  getDelay(failureCount) {
+    if (this.min < 0) throw new Error("RetryDelaySeq.min must be non-negative.");
+    if (failureCount <= 0) return 0;
+    if (this.multiplier <= 1) {
+      return Math.max(0, this.spread <= 0 ? this.min : applySpread(this.min, this.spread));
+    }
+    const multiplier = Math.pow(this.multiplier, failureCount - 1);
+    const raw = Math.min(this.max, this.min * multiplier);
+    return Math.max(0, applySpread(raw, this.spread));
+  }
+};
+
+// src/retry-delayer.ts
+var RetryDelayNone = {
+  promise: Promise.resolve(),
+  endsAt: 0,
+  isLimitExceeded: false
+};
+var RetryDelayLimitExceeded = {
+  promise: Promise.resolve(),
+  endsAt: 0,
+  isLimitExceeded: true
+};
+var RetryDelayer = class {
+  _cancelController = new AbortController();
+  delays = RetryDelaySeq.fixed(1e3);
+  limit = void 0;
+  cancelDelaysChanged = new EventHandlerSet();
+  getDelay(tryIndex, cancellationSignal) {
+    if (this.limit !== void 0 && tryIndex >= this.limit)
+      return RetryDelayLimitExceeded;
+    const delayMs = this.delays.getDelay(tryIndex);
+    if (tryIndex === 0 || delayMs <= 0)
+      return RetryDelayNone;
+    const actualDelayMs = Math.max(1, delayMs);
+    const endsAt = Date.now() + actualDelayMs;
+    const cancelSignal = this._cancelController.signal;
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        resolve();
+      }, actualDelayMs);
+      const onCancel = () => {
+        clearTimeout(timer);
+        cleanup();
+        resolve();
+      };
+      const onAbort = () => {
+        clearTimeout(timer);
+        cleanup();
+        reject(new Error("Retry delay aborted."));
+      };
+      const cleanup = () => {
+        cancelSignal.removeEventListener("abort", onCancel);
+        cancellationSignal?.removeEventListener("abort", onAbort);
+      };
+      cancelSignal.addEventListener("abort", onCancel, { once: true });
+      cancellationSignal?.addEventListener("abort", onAbort, { once: true });
+    });
+    return { promise, endsAt, isLimitExceeded: false };
+  }
+  cancelDelays() {
+    const old = this._cancelController;
+    this._cancelController = new AbortController();
+    old.abort();
+    this.cancelDelaysChanged.trigger();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncContext,
+  AsyncContextKey,
+  AsyncLock,
+  DisposableBag,
+  EventHandlerSet,
+  PromiseSource,
+  Result,
+  RetryDelayLimitExceeded,
+  RetryDelayNone,
+  RetryDelaySeq,
+  RetryDelayer,
+  abortSignalKey,
+  errorResult,
+  resolvedVoidPromise,
+  result,
+  resultFrom,
+  resultFromAsync
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/polyfills.ts","../src/async-context.ts","../src/async-lock.ts","../src/disposable.ts","../src/promise-source.ts","../src/events.ts","../src/result.ts","../src/retry-delay-seq.ts","../src/retry-delayer.ts"],"sourcesContent":["import \"./polyfills.js\";\r\nexport { AsyncContext, AsyncContextKey, abortSignalKey } from \"./async-context.js\";\r\nexport { AsyncLock } from \"./async-lock.js\";\r\nexport type { Disposable, AsyncDisposable } from \"./disposable.js\";\r\nexport { DisposableBag } from \"./disposable.js\";\r\nexport { EventHandlerSet } from \"./events.js\";\r\nexport { PromiseSource, resolvedVoidPromise } from \"./promise-source.js\";\r\nexport type { IResult } from \"./result.js\";\r\nexport { Result, result, errorResult, resultFrom, resultFromAsync } from \"./result.js\";\r\nexport { RetryDelaySeq } from \"./retry-delay-seq.js\";\r\nexport type { RetryDelay } from \"./retry-delayer.js\";\r\nexport { RetryDelayer, RetryDelayNone, RetryDelayLimitExceeded } from \"./retry-delayer.js\";\r\n","// TC39 decorator metadata polyfill — required for Symbol.metadata support\r\n// in runtimes that don't yet implement it natively.\r\n(Symbol as any).metadata ??= Symbol(\"Symbol.metadata\");\r\n","import type { Disposable } from \"./disposable.js\";\r\n\r\n/** Typed key for values stored in AsyncContext — each subsystem defines its own keys. */\r\nexport class AsyncContextKey<T> {\r\n  readonly id: symbol;\r\n  readonly defaultValue: T;\r\n\r\n  constructor(name: string, defaultValue: T) {\r\n    this.id = Symbol(name);\r\n    this.defaultValue = defaultValue;\r\n  }\r\n}\r\n\r\n/** General-purpose typed context container — named for forward-compatibility with TC39 AsyncContext proposal. */\r\nexport const abortSignalKey =\r\n  new AsyncContextKey<AbortSignal | undefined>(\"AbortSignal\", undefined);\r\n\r\nexport class AsyncContext {\r\n  static current: AsyncContext | undefined = undefined;\r\n\r\n  /** Immutable empty singleton — avoids allocating new AsyncContext(). */\r\n  static readonly empty: AsyncContext = new AsyncContext();\r\n\r\n  private static _defaults = new Map<symbol, unknown>();\r\n\r\n  private _values: Map<symbol, unknown>;\r\n\r\n  constructor(values?: Map<symbol, unknown>) {\r\n    this._values = values ?? new Map();\r\n  }\r\n\r\n  get<T>(key: AsyncContextKey<T>): T {\r\n    if (this._values.has(key.id)) return this._values.get(key.id) as T;\r\n    if (AsyncContext._defaults.has(key.id)) return AsyncContext._defaults.get(key.id) as T;\r\n    return key.defaultValue;\r\n  }\r\n\r\n  with<T>(key: AsyncContextKey<T>, value: T): AsyncContext {\r\n    const copy = new Map(this._values);\r\n    copy.set(key.id, value);\r\n    return new AsyncContext(copy);\r\n  }\r\n\r\n  activate(): Disposable {\r\n    const prev = AsyncContext.current;\r\n    AsyncContext.current = this;\r\n    return { dispose: () => { AsyncContext.current = prev; } };\r\n  }\r\n\r\n  run<R>(fn: () => R): R {\r\n    const prev = AsyncContext.current;\r\n    AsyncContext.current = this;\r\n    try {\r\n      return fn();\r\n    } finally {\r\n      AsyncContext.current = prev;\r\n    }\r\n  }\r\n\r\n  /** Strip THIS exact instance from args if it's the last element (reference equality). */\r\n  stripFromArgs(args: unknown[]): unknown[] {\r\n    return args[args.length - 1] === this ? args.slice(0, -1) : args;\r\n  }\r\n\r\n  /** Resolve: return ctx if provided, otherwise AsyncContext.current. */\r\n  static from(ctx: AsyncContext | undefined): AsyncContext | undefined {\r\n    return ctx ?? AsyncContext.current;\r\n  }\r\n\r\n  /** Extract AsyncContext from last arg if instanceof AsyncContext, else fall back to .current. */\r\n  static fromArgs(args: unknown[]): AsyncContext | undefined {\r\n    const last = args[args.length - 1];\r\n    return last instanceof AsyncContext ? last : AsyncContext.current;\r\n  }\r\n\r\n  static setDefault<T>(key: AsyncContextKey<T>, value: T): void {\r\n    AsyncContext._defaults.set(key.id, value);\r\n  }\r\n\r\n  static getOrCreate(): AsyncContext {\r\n    return AsyncContext.current ?? AsyncContext.empty;\r\n  }\r\n}\r\n","/** Promise-based mutual exclusion lock for serializing async operations. */\r\nexport class AsyncLock {\r\n  private _queue: (() => void)[] = [];\r\n  private _locked = false;\r\n\r\n  get isLocked(): boolean {\r\n    return this._locked;\r\n  }\r\n\r\n  async acquire(): Promise<void> {\r\n    if (!this._locked) {\r\n      this._locked = true;\r\n      return;\r\n    }\r\n    return new Promise<void>((resolve) => {\r\n      this._queue.push(resolve);\r\n    });\r\n  }\r\n\r\n  release(): void {\r\n    if (!this._locked)\r\n      throw new Error(\"AsyncLock is not locked.\");\r\n\r\n    const next = this._queue.shift();\r\n    if (next !== undefined) {\r\n      // Transfer lock to the next waiter\r\n      next();\r\n    } else {\r\n      this._locked = false;\r\n    }\r\n  }\r\n\r\n  async run<T>(fn: () => T | Promise<T>): Promise<T> {\r\n    await this.acquire();\r\n    try {\r\n      return await fn();\r\n    } finally {\r\n      this.release();\r\n    }\r\n  }\r\n}\r\n","/** Synchronous dispose pattern, similar to .NET's IDisposable. */\r\nexport interface Disposable {\r\n  dispose(): void;\r\n}\r\n\r\n/** Asynchronous dispose pattern, similar to .NET's IAsyncDisposable. */\r\nexport interface AsyncDisposable {\r\n  disposeAsync(): Promise<void>;\r\n}\r\n\r\n/** Aggregates multiple disposables and disposes them together. */\r\nexport class DisposableBag implements Disposable, AsyncDisposable {\r\n  private _items: (Disposable | AsyncDisposable)[] = [];\r\n  private _disposed = false;\r\n\r\n  get isDisposed(): boolean {\r\n    return this._disposed;\r\n  }\r\n\r\n  add(item: Disposable | AsyncDisposable): void {\r\n    if (this._disposed)\r\n      throw new Error(\"DisposableBag is already disposed.\");\r\n    this._items.push(item);\r\n  }\r\n\r\n  dispose(): void {\r\n    if (this._disposed) return;\r\n    this._disposed = true;\r\n    const items = this._items;\r\n    this._items = [];\r\n    // Dispose in reverse order (LIFO)\r\n    for (let i = items.length - 1; i >= 0; i--) {\r\n      const item = items[i];\r\n      if (item != null && \"dispose\" in item) item.dispose();\r\n    }\r\n  }\r\n\r\n  async disposeAsync(): Promise<void> {\r\n    if (this._disposed) return;\r\n    this._disposed = true;\r\n    const items = this._items;\r\n    this._items = [];\r\n    for (let i = items.length - 1; i >= 0; i--) {\r\n      const item = items[i];\r\n      if (item == null) continue;\r\n      if (\"disposeAsync\" in item) await item.disposeAsync();\r\n      else if (\"dispose\" in item) item.dispose();\r\n    }\r\n  }\r\n}\r\n","/** Externally-resolvable promise — similar to .NET's TaskCompletionSource<T>. */\r\nexport class PromiseSource<T> {\r\n  readonly promise: Promise<T>;\r\n  private _resolve!: (value: T | PromiseLike<T>) => void;\r\n  private _reject!: (reason?: unknown) => void;\r\n  private _isCompleted = false;\r\n\r\n  constructor() {\r\n    this.promise = new Promise<T>((resolve, reject) => {\r\n      this._resolve = resolve;\r\n      this._reject = reject;\r\n    });\r\n  }\r\n\r\n  get isCompleted(): boolean {\r\n    return this._isCompleted;\r\n  }\r\n\r\n  resolve(value: T): boolean {\r\n    if (this._isCompleted) return false;\r\n    this._isCompleted = true;\r\n    this._resolve(value);\r\n    return true;\r\n  }\r\n\r\n  reject(reason?: unknown): boolean {\r\n    if (this._isCompleted) return false;\r\n    this._isCompleted = true;\r\n    this._reject(reason);\r\n    return true;\r\n  }\r\n}\r\n\r\nexport const resolvedVoidPromise: Promise<void> = Promise.resolve();","import { PromiseSource } from \"./promise-source.js\";\r\n\r\n/** Typed pub/sub event handler set — similar to .NET's EventHandler<T> multicast delegate. */\r\nexport class EventHandlerSet<T> {\r\n  private _handlers: Set<(arg: T) => void> = new Set();\r\n\r\n  get count(): number {\r\n    return this._handlers.size;\r\n  }\r\n\r\n  add(handler: (arg: T) => void): void {\r\n    this._handlers.add(handler);\r\n  }\r\n\r\n  remove(handler: (arg: T) => void): void {\r\n    this._handlers.delete(handler);\r\n  }\r\n\r\n  trigger(arg: T): void {\r\n    for (const handler of this._handlers) handler(arg);\r\n  }\r\n\r\n  clear(): void {\r\n    this._handlers.clear();\r\n  }\r\n\r\n  whenNext(): Promise<T> {\r\n    const ps = new PromiseSource<T>();\r\n    const handler = (arg: T) => {\r\n      this._handlers.delete(handler);\r\n      ps.resolve(arg);\r\n    };\r\n    this._handlers.add(handler);\r\n    return ps.promise;\r\n  }\r\n}\r\n","/** Common interface for types that carry a value-or-error outcome. */\r\nexport interface IResult<T> {\r\n  readonly hasValue: boolean;\r\n  readonly hasError: boolean;\r\n  readonly value: T;\r\n  readonly error: unknown;\r\n  readonly valueOrUndefined: T | undefined;\r\n}\r\n\r\n/** Immutable value-or-error container — similar to .NET's Result<T>. */\r\nexport class Result<T> implements IResult<T> {\r\n  readonly hasValue: boolean;\r\n  readonly hasError: boolean;\r\n  private readonly _value: T | undefined;\r\n  private readonly _error: unknown;\r\n\r\n  public constructor(value: T | undefined, error?: unknown) {\r\n    this.hasValue = error === undefined;\r\n    this.hasError = !this.hasValue;\r\n    this._value = value;\r\n    this._error = error;\r\n  }\r\n\r\n  get value(): T {\r\n    if (this.hasError) throw this._error;\r\n    return this._value as T;\r\n  }\r\n\r\n  get error(): unknown {\r\n    return this._error;\r\n  }\r\n\r\n  get valueOrUndefined(): T | undefined {\r\n    return this.hasValue ? this._value : undefined;\r\n  }\r\n\r\n  static ok<T>(value: T): Result<T> {\r\n    return new Result<T>(value);\r\n  }\r\n\r\n  static error<T>(error: unknown): Result<T> {\r\n    return new Result<T>(undefined, error);\r\n  }\r\n}\r\n\r\nexport function result<T>(value: T, error?: unknown): Result<T> {\r\n  return new Result<T>(value, error);\r\n}\r\n\r\nexport function errorResult<T>(error: unknown): Result<T> {\r\n  return Result.error(error);\r\n}\r\n\r\nexport function resultFrom<T>(fn: () => T): Result<T> {\r\n  try {\r\n    return result(fn());\r\n  } catch (e) {\r\n    return errorResult(e);\r\n  }\r\n}\r\n\r\nexport async function resultFromAsync<T>(fn: () => Promise<T>): Promise<Result<T>> {\r\n  try {\r\n    return result(await fn());\r\n  } catch (e) {\r\n    return errorResult(e);\r\n  }\r\n}\r\n","// .NET counterpart: ActualLab.Time.RetryDelaySeq\r\n\r\nconst DefaultSpread = 0.1;\r\nconst DefaultMultiplier = 1.41421356237; // Math.sqrt(2)\r\n\r\nfunction applySpread(origin: number, spread: number): number {\r\n  if (spread <= 0) return origin;\r\n  const delta = origin * spread;\r\n  return origin + (Math.random() * 2 - 1) * delta;\r\n}\r\n\r\nexport class RetryDelaySeq {\r\n  readonly min: number;\r\n  readonly max: number;\r\n  readonly spread: number;\r\n  readonly multiplier: number;\r\n\r\n  constructor(min: number, max: number, spread: number = DefaultSpread, multiplier: number = DefaultMultiplier) {\r\n    this.min = min;\r\n    this.max = max;\r\n    this.spread = spread;\r\n    this.multiplier = multiplier;\r\n  }\r\n\r\n  static fixed(delayMs: number, spread: number = DefaultSpread): RetryDelaySeq {\r\n    return new RetryDelaySeq(delayMs, delayMs, spread, 1);\r\n  }\r\n\r\n  static exp(\r\n    minMs: number,\r\n    maxMs: number,\r\n    spread: number = DefaultSpread,\r\n    multiplier: number = DefaultMultiplier,\r\n  ): RetryDelaySeq {\r\n    return new RetryDelaySeq(minMs, maxMs, spread, multiplier);\r\n  }\r\n\r\n  getDelay(failureCount: number): number {\r\n    if (this.min < 0) throw new Error(\"RetryDelaySeq.min must be non-negative.\");\r\n    if (failureCount <= 0) return 0;\r\n\r\n    if (this.multiplier <= 1) {\r\n      // Fixed — no exponential component\r\n      return Math.max(0, this.spread <= 0 ? this.min : applySpread(this.min, this.spread));\r\n    }\r\n\r\n    const multiplier = Math.pow(this.multiplier, failureCount - 1);\r\n    const raw = Math.min(this.max, this.min * multiplier);\r\n    return Math.max(0, applySpread(raw, this.spread));\r\n  }\r\n}\r\n","// .NET counterparts: ActualLab.Net.RetryDelayer, ActualLab.Net.RetryDelay\r\n\r\nimport { EventHandlerSet } from \"./events.js\";\r\nimport { RetryDelaySeq } from \"./retry-delay-seq.js\";\r\n\r\nexport interface RetryDelay {\r\n  readonly promise: Promise<void>;\r\n  readonly endsAt: number;       // Date.now()-based timestamp, 0 = no delay\r\n  readonly isLimitExceeded: boolean;\r\n}\r\n\r\nexport const RetryDelayNone: RetryDelay = {\r\n  promise: Promise.resolve(),\r\n  endsAt: 0,\r\n  isLimitExceeded: false,\r\n};\r\n\r\nexport const RetryDelayLimitExceeded: RetryDelay = {\r\n  promise: Promise.resolve(),\r\n  endsAt: 0,\r\n  isLimitExceeded: true,\r\n};\r\n\r\nexport class RetryDelayer {\r\n  private _cancelController = new AbortController();\r\n\r\n  delays: RetryDelaySeq = RetryDelaySeq.fixed(1000);\r\n  limit: number | undefined = undefined;\r\n\r\n  readonly cancelDelaysChanged = new EventHandlerSet<void>();\r\n\r\n  getDelay(tryIndex: number, cancellationSignal?: AbortSignal): RetryDelay {\r\n    if (this.limit !== undefined && tryIndex >= this.limit)\r\n      return RetryDelayLimitExceeded;\r\n\r\n    const delayMs = this.delays.getDelay(tryIndex);\r\n    if (tryIndex === 0 || delayMs <= 0)\r\n      return RetryDelayNone;\r\n\r\n    const actualDelayMs = Math.max(1, delayMs);\r\n    const endsAt = Date.now() + actualDelayMs;\r\n\r\n    const cancelSignal = this._cancelController.signal;\r\n    const promise = new Promise<void>((resolve, reject) => {\r\n      const timer = setTimeout(() => {\r\n        cleanup();\r\n        resolve();\r\n      }, actualDelayMs);\r\n\r\n      const onCancel = () => {\r\n        clearTimeout(timer);\r\n        cleanup();\r\n        resolve(); // cancelDelays resolves, does NOT reject\r\n      };\r\n\r\n      const onAbort = () => {\r\n        clearTimeout(timer);\r\n        cleanup();\r\n        reject(new Error(\"Retry delay aborted.\"));\r\n      };\r\n\r\n      const cleanup = () => {\r\n        cancelSignal.removeEventListener(\"abort\", onCancel);\r\n        cancellationSignal?.removeEventListener(\"abort\", onAbort);\r\n      };\r\n\r\n      cancelSignal.addEventListener(\"abort\", onCancel, { once: true });\r\n      cancellationSignal?.addEventListener(\"abort\", onAbort, { once: true });\r\n    });\r\n\r\n    return { promise, endsAt, isLimitExceeded: false };\r\n  }\r\n\r\n  cancelDelays(): void {\r\n    const old = this._cancelController;\r\n    this._cancelController = new AbortController();\r\n    old.abort();\r\n    this.cancelDelaysChanged.trigger();\r\n  }\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,135 @@
+/** Synchronous dispose pattern, similar to .NET's IDisposable. */
+interface Disposable {
+    dispose(): void;
+}
+/** Asynchronous dispose pattern, similar to .NET's IAsyncDisposable. */
+interface AsyncDisposable {
+    disposeAsync(): Promise<void>;
+}
+/** Aggregates multiple disposables and disposes them together. */
+declare class DisposableBag implements Disposable, AsyncDisposable {
+    private _items;
+    private _disposed;
+    get isDisposed(): boolean;
+    add(item: Disposable | AsyncDisposable): void;
+    dispose(): void;
+    disposeAsync(): Promise<void>;
+}
+
+/** Typed key for values stored in AsyncContext — each subsystem defines its own keys. */
+declare class AsyncContextKey<T> {
+    readonly id: symbol;
+    readonly defaultValue: T;
+    constructor(name: string, defaultValue: T);
+}
+/** General-purpose typed context container — named for forward-compatibility with TC39 AsyncContext proposal. */
+declare const abortSignalKey: AsyncContextKey<AbortSignal | undefined>;
+declare class AsyncContext {
+    static current: AsyncContext | undefined;
+    /** Immutable empty singleton — avoids allocating new AsyncContext(). */
+    static readonly empty: AsyncContext;
+    private static _defaults;
+    private _values;
+    constructor(values?: Map<symbol, unknown>);
+    get<T>(key: AsyncContextKey<T>): T;
+    with<T>(key: AsyncContextKey<T>, value: T): AsyncContext;
+    activate(): Disposable;
+    run<R>(fn: () => R): R;
+    /** Strip THIS exact instance from args if it's the last element (reference equality). */
+    stripFromArgs(args: unknown[]): unknown[];
+    /** Resolve: return ctx if provided, otherwise AsyncContext.current. */
+    static from(ctx: AsyncContext | undefined): AsyncContext | undefined;
+    /** Extract AsyncContext from last arg if instanceof AsyncContext, else fall back to .current. */
+    static fromArgs(args: unknown[]): AsyncContext | undefined;
+    static setDefault<T>(key: AsyncContextKey<T>, value: T): void;
+    static getOrCreate(): AsyncContext;
+}
+
+/** Promise-based mutual exclusion lock for serializing async operations. */
+declare class AsyncLock {
+    private _queue;
+    private _locked;
+    get isLocked(): boolean;
+    acquire(): Promise<void>;
+    release(): void;
+    run<T>(fn: () => T | Promise<T>): Promise<T>;
+}
+
+/** Typed pub/sub event handler set — similar to .NET's EventHandler<T> multicast delegate. */
+declare class EventHandlerSet<T> {
+    private _handlers;
+    get count(): number;
+    add(handler: (arg: T) => void): void;
+    remove(handler: (arg: T) => void): void;
+    trigger(arg: T): void;
+    clear(): void;
+    whenNext(): Promise<T>;
+}
+
+/** Externally-resolvable promise — similar to .NET's TaskCompletionSource<T>. */
+declare class PromiseSource<T> {
+    readonly promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    private _isCompleted;
+    constructor();
+    get isCompleted(): boolean;
+    resolve(value: T): boolean;
+    reject(reason?: unknown): boolean;
+}
+declare const resolvedVoidPromise: Promise<void>;
+
+/** Common interface for types that carry a value-or-error outcome. */
+interface IResult<T> {
+    readonly hasValue: boolean;
+    readonly hasError: boolean;
+    readonly value: T;
+    readonly error: unknown;
+    readonly valueOrUndefined: T | undefined;
+}
+/** Immutable value-or-error container — similar to .NET's Result<T>. */
+declare class Result<T> implements IResult<T> {
+    readonly hasValue: boolean;
+    readonly hasError: boolean;
+    private readonly _value;
+    private readonly _error;
+    constructor(value: T | undefined, error?: unknown);
+    get value(): T;
+    get error(): unknown;
+    get valueOrUndefined(): T | undefined;
+    static ok<T>(value: T): Result<T>;
+    static error<T>(error: unknown): Result<T>;
+}
+declare function result<T>(value: T, error?: unknown): Result<T>;
+declare function errorResult<T>(error: unknown): Result<T>;
+declare function resultFrom<T>(fn: () => T): Result<T>;
+declare function resultFromAsync<T>(fn: () => Promise<T>): Promise<Result<T>>;
+
+declare class RetryDelaySeq {
+    readonly min: number;
+    readonly max: number;
+    readonly spread: number;
+    readonly multiplier: number;
+    constructor(min: number, max: number, spread?: number, multiplier?: number);
+    static fixed(delayMs: number, spread?: number): RetryDelaySeq;
+    static exp(minMs: number, maxMs: number, spread?: number, multiplier?: number): RetryDelaySeq;
+    getDelay(failureCount: number): number;
+}
+
+interface RetryDelay {
+    readonly promise: Promise<void>;
+    readonly endsAt: number;
+    readonly isLimitExceeded: boolean;
+}
+declare const RetryDelayNone: RetryDelay;
+declare const RetryDelayLimitExceeded: RetryDelay;
+declare class RetryDelayer {
+    private _cancelController;
+    delays: RetryDelaySeq;
+    limit: number | undefined;
+    readonly cancelDelaysChanged: EventHandlerSet<void>;
+    getDelay(tryIndex: number, cancellationSignal?: AbortSignal): RetryDelay;
+    cancelDelays(): void;
+}
+
+export { AsyncContext, AsyncContextKey, type AsyncDisposable, AsyncLock, type Disposable, DisposableBag, EventHandlerSet, type IResult, PromiseSource, Result, type RetryDelay, RetryDelayLimitExceeded, RetryDelayNone, RetryDelaySeq, RetryDelayer, abortSignalKey, errorResult, resolvedVoidPromise, result, resultFrom, resultFromAsync };

package/dist/index.d.ts

@@ -0,0 +1,135 @@
+/** Synchronous dispose pattern, similar to .NET's IDisposable. */
+interface Disposable {
+    dispose(): void;
+}
+/** Asynchronous dispose pattern, similar to .NET's IAsyncDisposable. */
+interface AsyncDisposable {
+    disposeAsync(): Promise<void>;
+}
+/** Aggregates multiple disposables and disposes them together. */
+declare class DisposableBag implements Disposable, AsyncDisposable {
+    private _items;
+    private _disposed;
+    get isDisposed(): boolean;
+    add(item: Disposable | AsyncDisposable): void;
+    dispose(): void;
+    disposeAsync(): Promise<void>;
+}
+
+/** Typed key for values stored in AsyncContext — each subsystem defines its own keys. */
+declare class AsyncContextKey<T> {
+    readonly id: symbol;
+    readonly defaultValue: T;
+    constructor(name: string, defaultValue: T);
+}
+/** General-purpose typed context container — named for forward-compatibility with TC39 AsyncContext proposal. */
+declare const abortSignalKey: AsyncContextKey<AbortSignal | undefined>;
+declare class AsyncContext {
+    static current: AsyncContext | undefined;
+    /** Immutable empty singleton — avoids allocating new AsyncContext(). */
+    static readonly empty: AsyncContext;
+    private static _defaults;
+    private _values;
+    constructor(values?: Map<symbol, unknown>);
+    get<T>(key: AsyncContextKey<T>): T;
+    with<T>(key: AsyncContextKey<T>, value: T): AsyncContext;
+    activate(): Disposable;
+    run<R>(fn: () => R): R;
+    /** Strip THIS exact instance from args if it's the last element (reference equality). */
+    stripFromArgs(args: unknown[]): unknown[];
+    /** Resolve: return ctx if provided, otherwise AsyncContext.current. */
+    static from(ctx: AsyncContext | undefined): AsyncContext | undefined;
+    /** Extract AsyncContext from last arg if instanceof AsyncContext, else fall back to .current. */
+    static fromArgs(args: unknown[]): AsyncContext | undefined;
+    static setDefault<T>(key: AsyncContextKey<T>, value: T): void;
+    static getOrCreate(): AsyncContext;
+}
+
+/** Promise-based mutual exclusion lock for serializing async operations. */
+declare class AsyncLock {
+    private _queue;
+    private _locked;
+    get isLocked(): boolean;
+    acquire(): Promise<void>;
+    release(): void;
+    run<T>(fn: () => T | Promise<T>): Promise<T>;
+}
+
+/** Typed pub/sub event handler set — similar to .NET's EventHandler<T> multicast delegate. */
+declare class EventHandlerSet<T> {
+    private _handlers;
+    get count(): number;
+    add(handler: (arg: T) => void): void;
+    remove(handler: (arg: T) => void): void;
+    trigger(arg: T): void;
+    clear(): void;
+    whenNext(): Promise<T>;
+}
+
+/** Externally-resolvable promise — similar to .NET's TaskCompletionSource<T>. */
+declare class PromiseSource<T> {
+    readonly promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    private _isCompleted;
+    constructor();
+    get isCompleted(): boolean;
+    resolve(value: T): boolean;
+    reject(reason?: unknown): boolean;
+}
+declare const resolvedVoidPromise: Promise<void>;
+
+/** Common interface for types that carry a value-or-error outcome. */
+interface IResult<T> {
+    readonly hasValue: boolean;
+    readonly hasError: boolean;
+    readonly value: T;
+    readonly error: unknown;
+    readonly valueOrUndefined: T | undefined;
+}
+/** Immutable value-or-error container — similar to .NET's Result<T>. */
+declare class Result<T> implements IResult<T> {
+    readonly hasValue: boolean;
+    readonly hasError: boolean;
+    private readonly _value;
+    private readonly _error;
+    constructor(value: T | undefined, error?: unknown);
+    get value(): T;
+    get error(): unknown;
+    get valueOrUndefined(): T | undefined;
+    static ok<T>(value: T): Result<T>;
+    static error<T>(error: unknown): Result<T>;
+}
+declare function result<T>(value: T, error?: unknown): Result<T>;
+declare function errorResult<T>(error: unknown): Result<T>;
+declare function resultFrom<T>(fn: () => T): Result<T>;
+declare function resultFromAsync<T>(fn: () => Promise<T>): Promise<Result<T>>;
+
+declare class RetryDelaySeq {
+    readonly min: number;
+    readonly max: number;
+    readonly spread: number;
+    readonly multiplier: number;
+    constructor(min: number, max: number, spread?: number, multiplier?: number);
+    static fixed(delayMs: number, spread?: number): RetryDelaySeq;
+    static exp(minMs: number, maxMs: number, spread?: number, multiplier?: number): RetryDelaySeq;
+    getDelay(failureCount: number): number;
+}
+
+interface RetryDelay {
+    readonly promise: Promise<void>;
+    readonly endsAt: number;
+    readonly isLimitExceeded: boolean;
+}
+declare const RetryDelayNone: RetryDelay;
+declare const RetryDelayLimitExceeded: RetryDelay;
+declare class RetryDelayer {
+    private _cancelController;
+    delays: RetryDelaySeq;
+    limit: number | undefined;
+    readonly cancelDelaysChanged: EventHandlerSet<void>;
+    getDelay(tryIndex: number, cancellationSignal?: AbortSignal): RetryDelay;
+    cancelDelays(): void;
+}
+
+export { AsyncContext, AsyncContextKey, type AsyncDisposable, AsyncLock, type Disposable, DisposableBag, EventHandlerSet, type IResult, PromiseSource, Result, type RetryDelay, RetryDelayLimitExceeded, RetryDelayNone, RetryDelaySeq, RetryDelayer, abortSignalKey, errorResult, resolvedVoidPromise, result, resultFrom, resultFromAsync };

package/dist/index.js

@@ -0,0 +1,363 @@
+// src/polyfills.ts
+Symbol.metadata ??= /* @__PURE__ */ Symbol("Symbol.metadata");
+
+// src/async-context.ts
+var AsyncContextKey = class {
+  id;
+  defaultValue;
+  constructor(name, defaultValue) {
+    this.id = Symbol(name);
+    this.defaultValue = defaultValue;
+  }
+};
+var abortSignalKey = new AsyncContextKey("AbortSignal", void 0);
+var AsyncContext = class _AsyncContext {
+  static current = void 0;
+  /** Immutable empty singleton — avoids allocating new AsyncContext(). */
+  static empty = new _AsyncContext();
+  static _defaults = /* @__PURE__ */ new Map();
+  _values;
+  constructor(values) {
+    this._values = values ?? /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (this._values.has(key.id)) return this._values.get(key.id);
+    if (_AsyncContext._defaults.has(key.id)) return _AsyncContext._defaults.get(key.id);
+    return key.defaultValue;
+  }
+  with(key, value) {
+    const copy = new Map(this._values);
+    copy.set(key.id, value);
+    return new _AsyncContext(copy);
+  }
+  activate() {
+    const prev = _AsyncContext.current;
+    _AsyncContext.current = this;
+    return { dispose: () => {
+      _AsyncContext.current = prev;
+    } };
+  }
+  run(fn) {
+    const prev = _AsyncContext.current;
+    _AsyncContext.current = this;
+    try {
+      return fn();
+    } finally {
+      _AsyncContext.current = prev;
+    }
+  }
+  /** Strip THIS exact instance from args if it's the last element (reference equality). */
+  stripFromArgs(args) {
+    return args[args.length - 1] === this ? args.slice(0, -1) : args;
+  }
+  /** Resolve: return ctx if provided, otherwise AsyncContext.current. */
+  static from(ctx) {
+    return ctx ?? _AsyncContext.current;
+  }
+  /** Extract AsyncContext from last arg if instanceof AsyncContext, else fall back to .current. */
+  static fromArgs(args) {
+    const last = args[args.length - 1];
+    return last instanceof _AsyncContext ? last : _AsyncContext.current;
+  }
+  static setDefault(key, value) {
+    _AsyncContext._defaults.set(key.id, value);
+  }
+  static getOrCreate() {
+    return _AsyncContext.current ?? _AsyncContext.empty;
+  }
+};
+
+// src/async-lock.ts
+var AsyncLock = class {
+  _queue = [];
+  _locked = false;
+  get isLocked() {
+    return this._locked;
+  }
+  async acquire() {
+    if (!this._locked) {
+      this._locked = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this._queue.push(resolve);
+    });
+  }
+  release() {
+    if (!this._locked)
+      throw new Error("AsyncLock is not locked.");
+    const next = this._queue.shift();
+    if (next !== void 0) {
+      next();
+    } else {
+      this._locked = false;
+    }
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+};
+
+// src/disposable.ts
+var DisposableBag = class {
+  _items = [];
+  _disposed = false;
+  get isDisposed() {
+    return this._disposed;
+  }
+  add(item) {
+    if (this._disposed)
+      throw new Error("DisposableBag is already disposed.");
+    this._items.push(item);
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    const items = this._items;
+    this._items = [];
+    for (let i = items.length - 1; i >= 0; i--) {
+      const item = items[i];
+      if (item != null && "dispose" in item) item.dispose();
+    }
+  }
+  async disposeAsync() {
+    if (this._disposed) return;
+    this._disposed = true;
+    const items = this._items;
+    this._items = [];
+    for (let i = items.length - 1; i >= 0; i--) {
+      const item = items[i];
+      if (item == null) continue;
+      if ("disposeAsync" in item) await item.disposeAsync();
+      else if ("dispose" in item) item.dispose();
+    }
+  }
+};
+
+// src/promise-source.ts
+var PromiseSource = class {
+  promise;
+  _resolve;
+  _reject;
+  _isCompleted = false;
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get isCompleted() {
+    return this._isCompleted;
+  }
+  resolve(value) {
+    if (this._isCompleted) return false;
+    this._isCompleted = true;
+    this._resolve(value);
+    return true;
+  }
+  reject(reason) {
+    if (this._isCompleted) return false;
+    this._isCompleted = true;
+    this._reject(reason);
+    return true;
+  }
+};
+var resolvedVoidPromise = Promise.resolve();
+
+// src/events.ts
+var EventHandlerSet = class {
+  _handlers = /* @__PURE__ */ new Set();
+  get count() {
+    return this._handlers.size;
+  }
+  add(handler) {
+    this._handlers.add(handler);
+  }
+  remove(handler) {
+    this._handlers.delete(handler);
+  }
+  trigger(arg) {
+    for (const handler of this._handlers) handler(arg);
+  }
+  clear() {
+    this._handlers.clear();
+  }
+  whenNext() {
+    const ps = new PromiseSource();
+    const handler = (arg) => {
+      this._handlers.delete(handler);
+      ps.resolve(arg);
+    };
+    this._handlers.add(handler);
+    return ps.promise;
+  }
+};
+
+// src/result.ts
+var Result = class _Result {
+  hasValue;
+  hasError;
+  _value;
+  _error;
+  constructor(value, error) {
+    this.hasValue = error === void 0;
+    this.hasError = !this.hasValue;
+    this._value = value;
+    this._error = error;
+  }
+  get value() {
+    if (this.hasError) throw this._error;
+    return this._value;
+  }
+  get error() {
+    return this._error;
+  }
+  get valueOrUndefined() {
+    return this.hasValue ? this._value : void 0;
+  }
+  static ok(value) {
+    return new _Result(value);
+  }
+  static error(error) {
+    return new _Result(void 0, error);
+  }
+};
+function result(value, error) {
+  return new Result(value, error);
+}
+function errorResult(error) {
+  return Result.error(error);
+}
+function resultFrom(fn) {
+  try {
+    return result(fn());
+  } catch (e) {
+    return errorResult(e);
+  }
+}
+async function resultFromAsync(fn) {
+  try {
+    return result(await fn());
+  } catch (e) {
+    return errorResult(e);
+  }
+}
+
+// src/retry-delay-seq.ts
+var DefaultSpread = 0.1;
+var DefaultMultiplier = 1.41421356237;
+function applySpread(origin, spread) {
+  if (spread <= 0) return origin;
+  const delta = origin * spread;
+  return origin + (Math.random() * 2 - 1) * delta;
+}
+var RetryDelaySeq = class _RetryDelaySeq {
+  min;
+  max;
+  spread;
+  multiplier;
+  constructor(min, max, spread = DefaultSpread, multiplier = DefaultMultiplier) {
+    this.min = min;
+    this.max = max;
+    this.spread = spread;
+    this.multiplier = multiplier;
+  }
+  static fixed(delayMs, spread = DefaultSpread) {
+    return new _RetryDelaySeq(delayMs, delayMs, spread, 1);
+  }
+  static exp(minMs, maxMs, spread = DefaultSpread, multiplier = DefaultMultiplier) {
+    return new _RetryDelaySeq(minMs, maxMs, spread, multiplier);
+  }
+  getDelay(failureCount) {
+    if (this.min < 0) throw new Error("RetryDelaySeq.min must be non-negative.");
+    if (failureCount <= 0) return 0;
+    if (this.multiplier <= 1) {
+      return Math.max(0, this.spread <= 0 ? this.min : applySpread(this.min, this.spread));
+    }
+    const multiplier = Math.pow(this.multiplier, failureCount - 1);
+    const raw = Math.min(this.max, this.min * multiplier);
+    return Math.max(0, applySpread(raw, this.spread));
+  }
+};
+
+// src/retry-delayer.ts
+var RetryDelayNone = {
+  promise: Promise.resolve(),
+  endsAt: 0,
+  isLimitExceeded: false
+};
+var RetryDelayLimitExceeded = {
+  promise: Promise.resolve(),
+  endsAt: 0,
+  isLimitExceeded: true
+};
+var RetryDelayer = class {
+  _cancelController = new AbortController();
+  delays = RetryDelaySeq.fixed(1e3);
+  limit = void 0;
+  cancelDelaysChanged = new EventHandlerSet();
+  getDelay(tryIndex, cancellationSignal) {
+    if (this.limit !== void 0 && tryIndex >= this.limit)
+      return RetryDelayLimitExceeded;
+    const delayMs = this.delays.getDelay(tryIndex);
+    if (tryIndex === 0 || delayMs <= 0)
+      return RetryDelayNone;
+    const actualDelayMs = Math.max(1, delayMs);
+    const endsAt = Date.now() + actualDelayMs;
+    const cancelSignal = this._cancelController.signal;
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        resolve();
+      }, actualDelayMs);
+      const onCancel = () => {
+        clearTimeout(timer);
+        cleanup();
+        resolve();
+      };
+      const onAbort = () => {
+        clearTimeout(timer);
+        cleanup();
+        reject(new Error("Retry delay aborted."));
+      };
+      const cleanup = () => {
+        cancelSignal.removeEventListener("abort", onCancel);
+        cancellationSignal?.removeEventListener("abort", onAbort);
+      };
+      cancelSignal.addEventListener("abort", onCancel, { once: true });
+      cancellationSignal?.addEventListener("abort", onAbort, { once: true });
+    });
+    return { promise, endsAt, isLimitExceeded: false };
+  }
+  cancelDelays() {
+    const old = this._cancelController;
+    this._cancelController = new AbortController();
+    old.abort();
+    this.cancelDelaysChanged.trigger();
+  }
+};
+export {
+  AsyncContext,
+  AsyncContextKey,
+  AsyncLock,
+  DisposableBag,
+  EventHandlerSet,
+  PromiseSource,
+  Result,
+  RetryDelayLimitExceeded,
+  RetryDelayNone,
+  RetryDelaySeq,
+  RetryDelayer,
+  abortSignalKey,
+  errorResult,
+  resolvedVoidPromise,
+  result,
+  resultFrom,
+  resultFromAsync
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/polyfills.ts","../src/async-context.ts","../src/async-lock.ts","../src/disposable.ts","../src/promise-source.ts","../src/events.ts","../src/result.ts","../src/retry-delay-seq.ts","../src/retry-delayer.ts"],"sourcesContent":["// TC39 decorator metadata polyfill — required for Symbol.metadata support\r\n// in runtimes that don't yet implement it natively.\r\n(Symbol as any).metadata ??= Symbol(\"Symbol.metadata\");\r\n","import type { Disposable } from \"./disposable.js\";\r\n\r\n/** Typed key for values stored in AsyncContext — each subsystem defines its own keys. */\r\nexport class AsyncContextKey<T> {\r\n  readonly id: symbol;\r\n  readonly defaultValue: T;\r\n\r\n  constructor(name: string, defaultValue: T) {\r\n    this.id = Symbol(name);\r\n    this.defaultValue = defaultValue;\r\n  }\r\n}\r\n\r\n/** General-purpose typed context container — named for forward-compatibility with TC39 AsyncContext proposal. */\r\nexport const abortSignalKey =\r\n  new AsyncContextKey<AbortSignal | undefined>(\"AbortSignal\", undefined);\r\n\r\nexport class AsyncContext {\r\n  static current: AsyncContext | undefined = undefined;\r\n\r\n  /** Immutable empty singleton — avoids allocating new AsyncContext(). */\r\n  static readonly empty: AsyncContext = new AsyncContext();\r\n\r\n  private static _defaults = new Map<symbol, unknown>();\r\n\r\n  private _values: Map<symbol, unknown>;\r\n\r\n  constructor(values?: Map<symbol, unknown>) {\r\n    this._values = values ?? new Map();\r\n  }\r\n\r\n  get<T>(key: AsyncContextKey<T>): T {\r\n    if (this._values.has(key.id)) return this._values.get(key.id) as T;\r\n    if (AsyncContext._defaults.has(key.id)) return AsyncContext._defaults.get(key.id) as T;\r\n    return key.defaultValue;\r\n  }\r\n\r\n  with<T>(key: AsyncContextKey<T>, value: T): AsyncContext {\r\n    const copy = new Map(this._values);\r\n    copy.set(key.id, value);\r\n    return new AsyncContext(copy);\r\n  }\r\n\r\n  activate(): Disposable {\r\n    const prev = AsyncContext.current;\r\n    AsyncContext.current = this;\r\n    return { dispose: () => { AsyncContext.current = prev; } };\r\n  }\r\n\r\n  run<R>(fn: () => R): R {\r\n    const prev = AsyncContext.current;\r\n    AsyncContext.current = this;\r\n    try {\r\n      return fn();\r\n    } finally {\r\n      AsyncContext.current = prev;\r\n    }\r\n  }\r\n\r\n  /** Strip THIS exact instance from args if it's the last element (reference equality). */\r\n  stripFromArgs(args: unknown[]): unknown[] {\r\n    return args[args.length - 1] === this ? args.slice(0, -1) : args;\r\n  }\r\n\r\n  /** Resolve: return ctx if provided, otherwise AsyncContext.current. */\r\n  static from(ctx: AsyncContext | undefined): AsyncContext | undefined {\r\n    return ctx ?? AsyncContext.current;\r\n  }\r\n\r\n  /** Extract AsyncContext from last arg if instanceof AsyncContext, else fall back to .current. */\r\n  static fromArgs(args: unknown[]): AsyncContext | undefined {\r\n    const last = args[args.length - 1];\r\n    return last instanceof AsyncContext ? last : AsyncContext.current;\r\n  }\r\n\r\n  static setDefault<T>(key: AsyncContextKey<T>, value: T): void {\r\n    AsyncContext._defaults.set(key.id, value);\r\n  }\r\n\r\n  static getOrCreate(): AsyncContext {\r\n    return AsyncContext.current ?? AsyncContext.empty;\r\n  }\r\n}\r\n","/** Promise-based mutual exclusion lock for serializing async operations. */\r\nexport class AsyncLock {\r\n  private _queue: (() => void)[] = [];\r\n  private _locked = false;\r\n\r\n  get isLocked(): boolean {\r\n    return this._locked;\r\n  }\r\n\r\n  async acquire(): Promise<void> {\r\n    if (!this._locked) {\r\n      this._locked = true;\r\n      return;\r\n    }\r\n    return new Promise<void>((resolve) => {\r\n      this._queue.push(resolve);\r\n    });\r\n  }\r\n\r\n  release(): void {\r\n    if (!this._locked)\r\n      throw new Error(\"AsyncLock is not locked.\");\r\n\r\n    const next = this._queue.shift();\r\n    if (next !== undefined) {\r\n      // Transfer lock to the next waiter\r\n      next();\r\n    } else {\r\n      this._locked = false;\r\n    }\r\n  }\r\n\r\n  async run<T>(fn: () => T | Promise<T>): Promise<T> {\r\n    await this.acquire();\r\n    try {\r\n      return await fn();\r\n    } finally {\r\n      this.release();\r\n    }\r\n  }\r\n}\r\n","/** Synchronous dispose pattern, similar to .NET's IDisposable. */\r\nexport interface Disposable {\r\n  dispose(): void;\r\n}\r\n\r\n/** Asynchronous dispose pattern, similar to .NET's IAsyncDisposable. */\r\nexport interface AsyncDisposable {\r\n  disposeAsync(): Promise<void>;\r\n}\r\n\r\n/** Aggregates multiple disposables and disposes them together. */\r\nexport class DisposableBag implements Disposable, AsyncDisposable {\r\n  private _items: (Disposable | AsyncDisposable)[] = [];\r\n  private _disposed = false;\r\n\r\n  get isDisposed(): boolean {\r\n    return this._disposed;\r\n  }\r\n\r\n  add(item: Disposable | AsyncDisposable): void {\r\n    if (this._disposed)\r\n      throw new Error(\"DisposableBag is already disposed.\");\r\n    this._items.push(item);\r\n  }\r\n\r\n  dispose(): void {\r\n    if (this._disposed) return;\r\n    this._disposed = true;\r\n    const items = this._items;\r\n    this._items = [];\r\n    // Dispose in reverse order (LIFO)\r\n    for (let i = items.length - 1; i >= 0; i--) {\r\n      const item = items[i];\r\n      if (item != null && \"dispose\" in item) item.dispose();\r\n    }\r\n  }\r\n\r\n  async disposeAsync(): Promise<void> {\r\n    if (this._disposed) return;\r\n    this._disposed = true;\r\n    const items = this._items;\r\n    this._items = [];\r\n    for (let i = items.length - 1; i >= 0; i--) {\r\n      const item = items[i];\r\n      if (item == null) continue;\r\n      if (\"disposeAsync\" in item) await item.disposeAsync();\r\n      else if (\"dispose\" in item) item.dispose();\r\n    }\r\n  }\r\n}\r\n","/** Externally-resolvable promise — similar to .NET's TaskCompletionSource<T>. */\r\nexport class PromiseSource<T> {\r\n  readonly promise: Promise<T>;\r\n  private _resolve!: (value: T | PromiseLike<T>) => void;\r\n  private _reject!: (reason?: unknown) => void;\r\n  private _isCompleted = false;\r\n\r\n  constructor() {\r\n    this.promise = new Promise<T>((resolve, reject) => {\r\n      this._resolve = resolve;\r\n      this._reject = reject;\r\n    });\r\n  }\r\n\r\n  get isCompleted(): boolean {\r\n    return this._isCompleted;\r\n  }\r\n\r\n  resolve(value: T): boolean {\r\n    if (this._isCompleted) return false;\r\n    this._isCompleted = true;\r\n    this._resolve(value);\r\n    return true;\r\n  }\r\n\r\n  reject(reason?: unknown): boolean {\r\n    if (this._isCompleted) return false;\r\n    this._isCompleted = true;\r\n    this._reject(reason);\r\n    return true;\r\n  }\r\n}\r\n\r\nexport const resolvedVoidPromise: Promise<void> = Promise.resolve();","import { PromiseSource } from \"./promise-source.js\";\r\n\r\n/** Typed pub/sub event handler set — similar to .NET's EventHandler<T> multicast delegate. */\r\nexport class EventHandlerSet<T> {\r\n  private _handlers: Set<(arg: T) => void> = new Set();\r\n\r\n  get count(): number {\r\n    return this._handlers.size;\r\n  }\r\n\r\n  add(handler: (arg: T) => void): void {\r\n    this._handlers.add(handler);\r\n  }\r\n\r\n  remove(handler: (arg: T) => void): void {\r\n    this._handlers.delete(handler);\r\n  }\r\n\r\n  trigger(arg: T): void {\r\n    for (const handler of this._handlers) handler(arg);\r\n  }\r\n\r\n  clear(): void {\r\n    this._handlers.clear();\r\n  }\r\n\r\n  whenNext(): Promise<T> {\r\n    const ps = new PromiseSource<T>();\r\n    const handler = (arg: T) => {\r\n      this._handlers.delete(handler);\r\n      ps.resolve(arg);\r\n    };\r\n    this._handlers.add(handler);\r\n    return ps.promise;\r\n  }\r\n}\r\n","/** Common interface for types that carry a value-or-error outcome. */\r\nexport interface IResult<T> {\r\n  readonly hasValue: boolean;\r\n  readonly hasError: boolean;\r\n  readonly value: T;\r\n  readonly error: unknown;\r\n  readonly valueOrUndefined: T | undefined;\r\n}\r\n\r\n/** Immutable value-or-error container — similar to .NET's Result<T>. */\r\nexport class Result<T> implements IResult<T> {\r\n  readonly hasValue: boolean;\r\n  readonly hasError: boolean;\r\n  private readonly _value: T | undefined;\r\n  private readonly _error: unknown;\r\n\r\n  public constructor(value: T | undefined, error?: unknown) {\r\n    this.hasValue = error === undefined;\r\n    this.hasError = !this.hasValue;\r\n    this._value = value;\r\n    this._error = error;\r\n  }\r\n\r\n  get value(): T {\r\n    if (this.hasError) throw this._error;\r\n    return this._value as T;\r\n  }\r\n\r\n  get error(): unknown {\r\n    return this._error;\r\n  }\r\n\r\n  get valueOrUndefined(): T | undefined {\r\n    return this.hasValue ? this._value : undefined;\r\n  }\r\n\r\n  static ok<T>(value: T): Result<T> {\r\n    return new Result<T>(value);\r\n  }\r\n\r\n  static error<T>(error: unknown): Result<T> {\r\n    return new Result<T>(undefined, error);\r\n  }\r\n}\r\n\r\nexport function result<T>(value: T, error?: unknown): Result<T> {\r\n  return new Result<T>(value, error);\r\n}\r\n\r\nexport function errorResult<T>(error: unknown): Result<T> {\r\n  return Result.error(error);\r\n}\r\n\r\nexport function resultFrom<T>(fn: () => T): Result<T> {\r\n  try {\r\n    return result(fn());\r\n  } catch (e) {\r\n    return errorResult(e);\r\n  }\r\n}\r\n\r\nexport async function resultFromAsync<T>(fn: () => Promise<T>): Promise<Result<T>> {\r\n  try {\r\n    return result(await fn());\r\n  } catch (e) {\r\n    return errorResult(e);\r\n  }\r\n}\r\n","// .NET counterpart: ActualLab.Time.RetryDelaySeq\r\n\r\nconst DefaultSpread = 0.1;\r\nconst DefaultMultiplier = 1.41421356237; // Math.sqrt(2)\r\n\r\nfunction applySpread(origin: number, spread: number): number {\r\n  if (spread <= 0) return origin;\r\n  const delta = origin * spread;\r\n  return origin + (Math.random() * 2 - 1) * delta;\r\n}\r\n\r\nexport class RetryDelaySeq {\r\n  readonly min: number;\r\n  readonly max: number;\r\n  readonly spread: number;\r\n  readonly multiplier: number;\r\n\r\n  constructor(min: number, max: number, spread: number = DefaultSpread, multiplier: number = DefaultMultiplier) {\r\n    this.min = min;\r\n    this.max = max;\r\n    this.spread = spread;\r\n    this.multiplier = multiplier;\r\n  }\r\n\r\n  static fixed(delayMs: number, spread: number = DefaultSpread): RetryDelaySeq {\r\n    return new RetryDelaySeq(delayMs, delayMs, spread, 1);\r\n  }\r\n\r\n  static exp(\r\n    minMs: number,\r\n    maxMs: number,\r\n    spread: number = DefaultSpread,\r\n    multiplier: number = DefaultMultiplier,\r\n  ): RetryDelaySeq {\r\n    return new RetryDelaySeq(minMs, maxMs, spread, multiplier);\r\n  }\r\n\r\n  getDelay(failureCount: number): number {\r\n    if (this.min < 0) throw new Error(\"RetryDelaySeq.min must be non-negative.\");\r\n    if (failureCount <= 0) return 0;\r\n\r\n    if (this.multiplier <= 1) {\r\n      // Fixed — no exponential component\r\n      return Math.max(0, this.spread <= 0 ? this.min : applySpread(this.min, this.spread));\r\n    }\r\n\r\n    const multiplier = Math.pow(this.multiplier, failureCount - 1);\r\n    const raw = Math.min(this.max, this.min * multiplier);\r\n    return Math.max(0, applySpread(raw, this.spread));\r\n  }\r\n}\r\n","// .NET counterparts: ActualLab.Net.RetryDelayer, ActualLab.Net.RetryDelay\r\n\r\nimport { EventHandlerSet } from \"./events.js\";\r\nimport { RetryDelaySeq } from \"./retry-delay-seq.js\";\r\n\r\nexport interface RetryDelay {\r\n  readonly promise: Promise<void>;\r\n  readonly endsAt: number;       // Date.now()-based timestamp, 0 = no delay\r\n  readonly isLimitExceeded: boolean;\r\n}\r\n\r\nexport const RetryDelayNone: RetryDelay = {\r\n  promise: Promise.resolve(),\r\n  endsAt: 0,\r\n  isLimitExceeded: false,\r\n};\r\n\r\nexport const RetryDelayLimitExceeded: RetryDelay = {\r\n  promise: Promise.resolve(),\r\n  endsAt: 0,\r\n  isLimitExceeded: true,\r\n};\r\n\r\nexport class RetryDelayer {\r\n  private _cancelController = new AbortController();\r\n\r\n  delays: RetryDelaySeq = RetryDelaySeq.fixed(1000);\r\n  limit: number | undefined = undefined;\r\n\r\n  readonly cancelDelaysChanged = new EventHandlerSet<void>();\r\n\r\n  getDelay(tryIndex: number, cancellationSignal?: AbortSignal): RetryDelay {\r\n    if (this.limit !== undefined && tryIndex >= this.limit)\r\n      return RetryDelayLimitExceeded;\r\n\r\n    const delayMs = this.delays.getDelay(tryIndex);\r\n    if (tryIndex === 0 || delayMs <= 0)\r\n      return RetryDelayNone;\r\n\r\n    const actualDelayMs = Math.max(1, delayMs);\r\n    const endsAt = Date.now() + actualDelayMs;\r\n\r\n    const cancelSignal = this._cancelController.signal;\r\n    const promise = new Promise<void>((resolve, reject) => {\r\n      const timer = setTimeout(() => {\r\n        cleanup();\r\n        resolve();\r\n      }, actualDelayMs);\r\n\r\n      const onCancel = () => {\r\n        clearTimeout(timer);\r\n        cleanup();\r\n        resolve(); // cancelDelays resolves, does NOT reject\r\n      };\r\n\r\n      const onAbort = () => {\r\n        clearTimeout(timer);\r\n        cleanup();\r\n        reject(new Error(\"Retry delay aborted.\"));\r\n      };\r\n\r\n      const cleanup = () => {\r\n        cancelSignal.removeEventListener(\"abort\", onCancel);\r\n        cancellationSignal?.removeEventListener(\"abort\", onAbort);\r\n      };\r\n\r\n      cancelSignal.addEventListener(\"abort\", onCancel, { once: true });\r\n      cancellationSignal?.addEventListener(\"abort\", onAbort, { once: true });\r\n    });\r\n\r\n    return { promise, endsAt, isLimitExceeded: false };\r\n  }\r\n\r\n  cancelDelays(): void {\r\n    const old = this._cancelController;\r\n    this._cancelController = new AbortController();\r\n    old.abort();\r\n    this.cancelDelaysChanged.trigger();\r\n  }\r\n}\r\n"],"mappings":";AAEC,OAAe,aAAa,uBAAO,iBAAiB;;;ACC9C,IAAM,kBAAN,MAAyB;AAAA,EACrB;AAAA,EACA;AAAA,EAET,YAAY,MAAc,cAAiB;AACzC,SAAK,KAAK,OAAO,IAAI;AACrB,SAAK,eAAe;AAAA,EACtB;AACF;AAGO,IAAM,iBACX,IAAI,gBAAyC,eAAe,MAAS;AAEhE,IAAM,eAAN,MAAM,cAAa;AAAA,EACxB,OAAO,UAAoC;AAAA;AAAA,EAG3C,OAAgB,QAAsB,IAAI,cAAa;AAAA,EAEvD,OAAe,YAAY,oBAAI,IAAqB;AAAA,EAE5C;AAAA,EAER,YAAY,QAA+B;AACzC,SAAK,UAAU,UAAU,oBAAI,IAAI;AAAA,EACnC;AAAA,EAEA,IAAO,KAA4B;AACjC,QAAI,KAAK,QAAQ,IAAI,IAAI,EAAE,EAAG,QAAO,KAAK,QAAQ,IAAI,IAAI,EAAE;AAC5D,QAAI,cAAa,UAAU,IAAI,IAAI,EAAE,EAAG,QAAO,cAAa,UAAU,IAAI,IAAI,EAAE;AAChF,WAAO,IAAI;AAAA,EACb;AAAA,EAEA,KAAQ,KAAyB,OAAwB;AACvD,UAAM,OAAO,IAAI,IAAI,KAAK,OAAO;AACjC,SAAK,IAAI,IAAI,IAAI,KAAK;AACtB,WAAO,IAAI,cAAa,IAAI;AAAA,EAC9B;AAAA,EAEA,WAAuB;AACrB,UAAM,OAAO,cAAa;AAC1B,kBAAa,UAAU;AACvB,WAAO,EAAE,SAAS,MAAM;AAAE,oBAAa,UAAU;AAAA,IAAM,EAAE;AAAA,EAC3D;AAAA,EAEA,IAAO,IAAgB;AACrB,UAAM,OAAO,cAAa;AAC1B,kBAAa,UAAU;AACvB,QAAI;AACF,aAAO,GAAG;AAAA,IACZ,UAAE;AACA,oBAAa,UAAU;AAAA,IACzB;AAAA,EACF;AAAA;AAAA,EAGA,cAAc,MAA4B;AACxC,WAAO,KAAK,KAAK,SAAS,CAAC,MAAM,OAAO,KAAK,MAAM,GAAG,EAAE,IAAI;AAAA,EAC9D;AAAA;AAAA,EAGA,OAAO,KAAK,KAAyD;AACnE,WAAO,OAAO,cAAa;AAAA,EAC7B;AAAA;AAAA,EAGA,OAAO,SAAS,MAA2C;AACzD,UAAM,OAAO,KAAK,KAAK,SAAS,CAAC;AACjC,WAAO,gBAAgB,gBAAe,OAAO,cAAa;AAAA,EAC5D;AAAA,EAEA,OAAO,WAAc,KAAyB,OAAgB;AAC5D,kBAAa,UAAU,IAAI,IAAI,IAAI,KAAK;AAAA,EAC1C;AAAA,EAEA,OAAO,cAA4B;AACjC,WAAO,cAAa,WAAW,cAAa;AAAA,EAC9C;AACF;;;ACjFO,IAAM,YAAN,MAAgB;AAAA,EACb,SAAyB,CAAC;AAAA,EAC1B,UAAU;AAAA,EAElB,IAAI,WAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,UAAyB;AAC7B,QAAI,CAAC,KAAK,SAAS;AACjB,WAAK,UAAU;AACf;AAAA,IACF;AACA,WAAO,IAAI,QAAc,CAAC,YAAY;AACpC,WAAK,OAAO,KAAK,OAAO;AAAA,IAC1B,CAAC;AAAA,EACH;AAAA,EAEA,UAAgB;AACd,QAAI,CAAC,KAAK;AACR,YAAM,IAAI,MAAM,0BAA0B;AAE5C,UAAM,OAAO,KAAK,OAAO,MAAM;AAC/B,QAAI,SAAS,QAAW;AAEtB,WAAK;AAAA,IACP,OAAO;AACL,WAAK,UAAU;AAAA,IACjB;AAAA,EACF;AAAA,EAEA,MAAM,IAAO,IAAsC;AACjD,UAAM,KAAK,QAAQ;AACnB,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,UAAE;AACA,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AACF;;;AC7BO,IAAM,gBAAN,MAA2D;AAAA,EACxD,SAA2C,CAAC;AAAA,EAC5C,YAAY;AAAA,EAEpB,IAAI,aAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,MAA0C;AAC5C,QAAI,KAAK;AACP,YAAM,IAAI,MAAM,oCAAoC;AACtD,SAAK,OAAO,KAAK,IAAI;AAAA,EACvB;AAAA,EAEA,UAAgB;AACd,QAAI,KAAK,UAAW;AACpB,SAAK,YAAY;AACjB,UAAM,QAAQ,KAAK;AACnB,SAAK,SAAS,CAAC;AAEf,aAAS,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;AAC1C,YAAM,OAAO,MAAM,CAAC;AACpB,UAAI,QAAQ,QAAQ,aAAa,KAAM,MAAK,QAAQ;AAAA,IACtD;AAAA,EACF;AAAA,EAEA,MAAM,eAA8B;AAClC,QAAI,KAAK,UAAW;AACpB,SAAK,YAAY;AACjB,UAAM,QAAQ,KAAK;AACnB,SAAK,SAAS,CAAC;AACf,aAAS,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;AAC1C,YAAM,OAAO,MAAM,CAAC;AACpB,UAAI,QAAQ,KAAM;AAClB,UAAI,kBAAkB,KAAM,OAAM,KAAK,aAAa;AAAA,eAC3C,aAAa,KAAM,MAAK,QAAQ;AAAA,IAC3C;AAAA,EACF;AACF;;;AChDO,IAAM,gBAAN,MAAuB;AAAA,EACnB;AAAA,EACD;AAAA,EACA;AAAA,EACA,eAAe;AAAA,EAEvB,cAAc;AACZ,SAAK,UAAU,IAAI,QAAW,CAAC,SAAS,WAAW;AACjD,WAAK,WAAW;AAChB,WAAK,UAAU;AAAA,IACjB,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,cAAuB;AACzB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,QAAQ,OAAmB;AACzB,QAAI,KAAK,aAAc,QAAO;AAC9B,SAAK,eAAe;AACpB,SAAK,SAAS,KAAK;AACnB,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,QAA2B;AAChC,QAAI,KAAK,aAAc,QAAO;AAC9B,SAAK,eAAe;AACpB,SAAK,QAAQ,MAAM;AACnB,WAAO;AAAA,EACT;AACF;AAEO,IAAM,sBAAqC,QAAQ,QAAQ;;;AC9B3D,IAAM,kBAAN,MAAyB;AAAA,EACtB,YAAmC,oBAAI,IAAI;AAAA,EAEnD,IAAI,QAAgB;AAClB,WAAO,KAAK,UAAU;AAAA,EACxB;AAAA,EAEA,IAAI,SAAiC;AACnC,SAAK,UAAU,IAAI,OAAO;AAAA,EAC5B;AAAA,EAEA,OAAO,SAAiC;AACtC,SAAK,UAAU,OAAO,OAAO;AAAA,EAC/B;AAAA,EAEA,QAAQ,KAAc;AACpB,eAAW,WAAW,KAAK,UAAW,SAAQ,GAAG;AAAA,EACnD;AAAA,EAEA,QAAc;AACZ,SAAK,UAAU,MAAM;AAAA,EACvB;AAAA,EAEA,WAAuB;AACrB,UAAM,KAAK,IAAI,cAAiB;AAChC,UAAM,UAAU,CAAC,QAAW;AAC1B,WAAK,UAAU,OAAO,OAAO;AAC7B,SAAG,QAAQ,GAAG;AAAA,IAChB;AACA,SAAK,UAAU,IAAI,OAAO;AAC1B,WAAO,GAAG;AAAA,EACZ;AACF;;;ACzBO,IAAM,SAAN,MAAM,QAAgC;AAAA,EAClC;AAAA,EACA;AAAA,EACQ;AAAA,EACA;AAAA,EAEV,YAAY,OAAsB,OAAiB;AACxD,SAAK,WAAW,UAAU;AAC1B,SAAK,WAAW,CAAC,KAAK;AACtB,SAAK,SAAS;AACd,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,IAAI,QAAW;AACb,QAAI,KAAK,SAAU,OAAM,KAAK;AAC9B,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,QAAiB;AACnB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,mBAAkC;AACpC,WAAO,KAAK,WAAW,KAAK,SAAS;AAAA,EACvC;AAAA,EAEA,OAAO,GAAM,OAAqB;AAChC,WAAO,IAAI,QAAU,KAAK;AAAA,EAC5B;AAAA,EAEA,OAAO,MAAS,OAA2B;AACzC,WAAO,IAAI,QAAU,QAAW,KAAK;AAAA,EACvC;AACF;AAEO,SAAS,OAAU,OAAU,OAA4B;AAC9D,SAAO,IAAI,OAAU,OAAO,KAAK;AACnC;AAEO,SAAS,YAAe,OAA2B;AACxD,SAAO,OAAO,MAAM,KAAK;AAC3B;AAEO,SAAS,WAAc,IAAwB;AACpD,MAAI;AACF,WAAO,OAAO,GAAG,CAAC;AAAA,EACpB,SAAS,GAAG;AACV,WAAO,YAAY,CAAC;AAAA,EACtB;AACF;AAEA,eAAsB,gBAAmB,IAA0C;AACjF,MAAI;AACF,WAAO,OAAO,MAAM,GAAG,CAAC;AAAA,EAC1B,SAAS,GAAG;AACV,WAAO,YAAY,CAAC;AAAA,EACtB;AACF;;;ACjEA,IAAM,gBAAgB;AACtB,IAAM,oBAAoB;AAE1B,SAAS,YAAY,QAAgB,QAAwB;AAC3D,MAAI,UAAU,EAAG,QAAO;AACxB,QAAM,QAAQ,SAAS;AACvB,SAAO,UAAU,KAAK,OAAO,IAAI,IAAI,KAAK;AAC5C;AAEO,IAAM,gBAAN,MAAM,eAAc;AAAA,EAChB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,KAAa,KAAa,SAAiB,eAAe,aAAqB,mBAAmB;AAC5G,SAAK,MAAM;AACX,SAAK,MAAM;AACX,SAAK,SAAS;AACd,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,OAAO,MAAM,SAAiB,SAAiB,eAA8B;AAC3E,WAAO,IAAI,eAAc,SAAS,SAAS,QAAQ,CAAC;AAAA,EACtD;AAAA,EAEA,OAAO,IACL,OACA,OACA,SAAiB,eACjB,aAAqB,mBACN;AACf,WAAO,IAAI,eAAc,OAAO,OAAO,QAAQ,UAAU;AAAA,EAC3D;AAAA,EAEA,SAAS,cAA8B;AACrC,QAAI,KAAK,MAAM,EAAG,OAAM,IAAI,MAAM,yCAAyC;AAC3E,QAAI,gBAAgB,EAAG,QAAO;AAE9B,QAAI,KAAK,cAAc,GAAG;AAExB,aAAO,KAAK,IAAI,GAAG,KAAK,UAAU,IAAI,KAAK,MAAM,YAAY,KAAK,KAAK,KAAK,MAAM,CAAC;AAAA,IACrF;AAEA,UAAM,aAAa,KAAK,IAAI,KAAK,YAAY,eAAe,CAAC;AAC7D,UAAM,MAAM,KAAK,IAAI,KAAK,KAAK,KAAK,MAAM,UAAU;AACpD,WAAO,KAAK,IAAI,GAAG,YAAY,KAAK,KAAK,MAAM,CAAC;AAAA,EAClD;AACF;;;ACvCO,IAAM,iBAA6B;AAAA,EACxC,SAAS,QAAQ,QAAQ;AAAA,EACzB,QAAQ;AAAA,EACR,iBAAiB;AACnB;AAEO,IAAM,0BAAsC;AAAA,EACjD,SAAS,QAAQ,QAAQ;AAAA,EACzB,QAAQ;AAAA,EACR,iBAAiB;AACnB;AAEO,IAAM,eAAN,MAAmB;AAAA,EAChB,oBAAoB,IAAI,gBAAgB;AAAA,EAEhD,SAAwB,cAAc,MAAM,GAAI;AAAA,EAChD,QAA4B;AAAA,EAEnB,sBAAsB,IAAI,gBAAsB;AAAA,EAEzD,SAAS,UAAkB,oBAA8C;AACvE,QAAI,KAAK,UAAU,UAAa,YAAY,KAAK;AAC/C,aAAO;AAET,UAAM,UAAU,KAAK,OAAO,SAAS,QAAQ;AAC7C,QAAI,aAAa,KAAK,WAAW;AAC/B,aAAO;AAET,UAAM,gBAAgB,KAAK,IAAI,GAAG,OAAO;AACzC,UAAM,SAAS,KAAK,IAAI,IAAI;AAE5B,UAAM,eAAe,KAAK,kBAAkB;AAC5C,UAAM,UAAU,IAAI,QAAc,CAAC,SAAS,WAAW;AACrD,YAAM,QAAQ,WAAW,MAAM;AAC7B,gBAAQ;AACR,gBAAQ;AAAA,MACV,GAAG,aAAa;AAEhB,YAAM,WAAW,MAAM;AACrB,qBAAa,KAAK;AAClB,gBAAQ;AACR,gBAAQ;AAAA,MACV;AAEA,YAAM,UAAU,MAAM;AACpB,qBAAa,KAAK;AAClB,gBAAQ;AACR,eAAO,IAAI,MAAM,sBAAsB,CAAC;AAAA,MAC1C;AAEA,YAAM,UAAU,MAAM;AACpB,qBAAa,oBAAoB,SAAS,QAAQ;AAClD,4BAAoB,oBAAoB,SAAS,OAAO;AAAA,MAC1D;AAEA,mBAAa,iBAAiB,SAAS,UAAU,EAAE,MAAM,KAAK,CAAC;AAC/D,0BAAoB,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,IACvE,CAAC;AAED,WAAO,EAAE,SAAS,QAAQ,iBAAiB,MAAM;AAAA,EACnD;AAAA,EAEA,eAAqB;AACnB,UAAM,MAAM,KAAK;AACjB,SAAK,oBAAoB,IAAI,gBAAgB;AAC7C,QAAI,MAAM;AACV,SAAK,oBAAoB,QAAQ;AAAA,EACnC;AACF;","names":[]}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@actuallab/core",
+  "version": "12.1.62",
+  "description": "Core primitives for ActualLab TypeScript libraries",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup --config ../../tsup.config.ts src/index.ts",
+    "clean": "rm -rf dist"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}