@oscarpalmer/atoms 0.222.0 → 0.223.0

package/dist/function/limit.d.mts

@@ -1,5 +1,5 @@
-import { GenericAsyncCallback, GenericCallback } from "../models/index.mjs";
 import { AsyncLimiter, Limiter } from "../models/function/limiter.model.mjs";
+import { GenericAsyncCallback, GenericCallback } from "../models/index.mjs";
 /**
  * Debounce a function, ensuring it is only called after `time` milliseconds have passed
  *

package/dist/function/limit.mjs

@@ -1,5 +1,5 @@
-import { LIMITER_DEBOUNCE, LIMITER_THROTTLE } from "../models/function/limiter.model.mjs";
 import { getAsyncLimiter, getLimiter } from "../internal/function/limit.mjs";
+import { LIMITER_DEBOUNCE, LIMITER_THROTTLE } from "../models/function/limiter.model.mjs";
 // src/function/limit.ts
 /**
 * Debounce a function, ensuring it is only called after `time` milliseconds have passed

package/dist/function/once.d.mts

@@ -1,5 +1,5 @@
-import { GenericAsyncCallback, GenericCallback } from "../models/index.mjs";
 import { AsyncOnce, Once } from "../models/function/once.model.mjs";
+import { GenericAsyncCallback, GenericCallback } from "../models/index.mjs";
 declare function AsyncOnce(this: any, callback: GenericAsyncCallback): void;
 declare function Once(this: any, callback: GenericCallback): void;
 /**

package/dist/function/once.mjs

@@ -1,5 +1,5 @@
 import { assert } from "../internal/function/assert.mjs";
-import { ONCE_MESSAGE_CLEARED, ONCE_MESSAGE_EXPECTATION, ONCE_NAME_ASYNC, ONCE_NAME_SYNC, ONCE_PROPERTY, ONCE_SYMBOL } from "../models/function/once.model.mjs";
+import { ONCE_MESSAGE_CLEARED, ONCE_MESSAGE_EXPECTATION, ONCE_NAME_ASYNC, ONCE_NAME_SYNC, ONCE_SYMBOL } from "../models/function/once.model.mjs";
 // src/function/once.ts
 function AsyncOnce(callback) {
 	this[ONCE_SYMBOL] = {
@@ -9,10 +9,10 @@ function AsyncOnce(callback) {
 		error: false,
 		finished: false,
 		items: [],
+		type: ONCE_NAME_ASYNC,
 		value: void 0
 	};
 }
-AsyncOnce.prototype[ONCE_PROPERTY] = ONCE_NAME_ASYNC;
 AsyncOnce.prototype.clear = clearOnce;
 AsyncOnce.prototype.run = runOnceAsync;
 Object.defineProperties(AsyncOnce.prototype, {
@@ -38,10 +38,10 @@ function Once(callback) {
 		callback,
 		called: false,
 		cleared: false,
+		type: ONCE_NAME_SYNC,
 		value: void 0
 	};
 }
-Once.prototype[ONCE_PROPERTY] = ONCE_NAME_SYNC;
 Once.prototype.clear = clearOnce;
 Once.prototype.run = runOnce;
 Object.defineProperties(Once.prototype, {
@@ -104,7 +104,7 @@ function handleOnceResult(state, value, error) {
 * @returns `true` if the value is an asynchronous once callback, otherwise `false`
 */
 function isAsyncOnce(value) {
-	return isOnceInstance(value, ONCE_NAME_ASYNC);
+	return isOnceInstance(ONCE_NAME_ASYNC, value);
 }
 /**
 * Is the value a once callback?
@@ -113,10 +113,10 @@ function isAsyncOnce(value) {
 * @returns `true` if the value is a once callback, otherwise `false`
 */
 function isOnce(value) {
-	return isOnceInstance(value, ONCE_NAME_SYNC);
+	return isOnceInstance(ONCE_NAME_SYNC, value);
 }
-function isOnceInstance(value, name) {
-	return typeof value === "object" && value !== null && "$once" in value && value["$once"] === name;
+function isOnceInstance(type, value) {
+	return typeof value === "object" && value !== null && ONCE_SYMBOL in value && value[ONCE_SYMBOL].type === type;
 }
 /**
 * Create a function that can only be called once, returning the same value on subsequent calls

package/dist/function/retry.d.mts

@@ -1,5 +1,5 @@
-import { GenericAsyncCallback, GenericCallback } from "../models/index.mjs";
 import { RetryError, RetryOptions } from "../models/function/retry.model.mjs";
+import { GenericAsyncCallback, GenericCallback } from "../models/index.mjs";
 /**
  * Retry a callback a specified number of times, with a delay between attempts
  *

package/dist/function/retry.mjs

@@ -1,8 +1,8 @@
+import { getNumberOrDefault } from "../internal/defaults.mjs";
+import { getLimiter } from "../internal/function/limit.mjs";
 import { isPlainObject } from "../internal/is.mjs";
 import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
 import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
-import { getNumberOrDefault } from "../internal/defaults.mjs";
-import { getLimiter } from "../internal/function/limit.mjs";
 import { RETRY_MESSAGE_EXPECTATION, RETRY_MESSAGE_FAILED, RetryError } from "../models/function/retry.model.mjs";
 // src/function/retry.ts
 /**
@@ -17,12 +17,12 @@ import { RETRY_MESSAGE_EXPECTATION, RETRY_MESSAGE_FAILED, RetryError } from "../
 async function asyncRetry(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
 	async function handle() {
-		const result = await asyncAttempt(async () => callback());
-		if (result.ok) {
-			resolver(result.value);
+		const attempted = await asyncAttempt(async () => callback());
+		if (attempted.ok) {
+			resolver(attempted.value);
 			return;
 		}
-		if (attempts >= times || !when(result.error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, result.error));
+		if (attempts >= times || !when(attempted.error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, attempted.error));
 		else {
 			attempts += 1;
 			limiter.run();
@@ -59,10 +59,10 @@ function retry(callback, options) {
 	const { times, when } = createRetryOptions(options);
 	let last;
 	for (let index = 0; index <= times; index += 1) {
-		const result = attempt(callback);
-		if (result.ok) return result.value;
-		if (index >= times || !when(result.error)) {
-			last = result.error;
+		const attempted = attempt(callback);
+		if (attempted.ok) return attempted.value;
+		if (index >= times || !when(attempted.error)) {
+			last = attempted.error;
 			break;
 		}
 	}

package/dist/herald.d.mts

@@ -1,3 +1,3 @@
+import { herald, isHerald, isHeraldEvents } from "./internal/herald.mjs";
 import { Herald, HeraldEvents, HeraldOptions } from "./models/herald.model.mjs";
-import { herald, isHerald, isHeraldEvents, isHeraldSubscription } from "./internal/herald.mjs";
-export { type Herald, type HeraldEvents, type HeraldOptions, herald, isHerald, isHeraldEvents, isHeraldSubscription };
+export { type Herald, type HeraldEvents, type HeraldOptions, herald, isHerald, isHeraldEvents };

package/dist/herald.mjs

@@ -1 +1 @@
-export { herald, isHerald, isHeraldEvents, isHeraldSubscription } from "./internal/herald.mjs";
+export { herald, isHerald, isHeraldEvents } from "./internal/herald.mjs";

package/dist/index.d.mts

@@ -3756,6 +3756,9 @@ export declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends
    * Is the _Map_ full?
    */
   get full(): boolean;
+  /**
+   * The maximum size of the _Map_
+   */
   get maximum(): number;
   /**
    * Create a new _SizedMap_ with entries and a maximum size _(2^20)_
@@ -4877,19 +4880,19 @@ type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
-   * @throws {PlanError<Yielded, Returned>}
+   * @throws {PlannedError<Yielded, Returned>}
    * @returns Result
    */
-  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlanReturned<Returned>> : (signal?: AbortSignal) => Promise<PlanReturned<Returned>>;
+  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlannedReturned<Returned>> : (signal?: AbortSignal) => Promise<PlannedReturned<Returned>>;
 };
 /**
  * An immediately succeeding or failing asynchronous plan
  */
-type AsyncPlanned<Value, Error> = AsyncSuccess<Value> | AsyncFailure<Error>;
+type AsyncImmediate<Value, Error> = AsyncSuccess<Value> | AsyncFailure<Error>;
 /**
  * A single asynchronous step within a plan of execution
  */
@@ -4932,6 +4935,10 @@ type Failure<Value> = {
    */
   [Symbol.iterator]: () => Generator<Err<Value>, never>;
 };
+/**
+ * An immediately succeeding or failing plan
+ */
+type Immediate<Value, Error> = Success<Value> | Failure<Error>;
 type InvalidAsyncStepValue<Input> = ((...args: any[]) => unknown) | ParameterizedPlan<Input>;
 type InvalidStepValue<Input> = ((...args: any[]) => unknown) | {
   [Symbol.asyncIterator]: unknown;
@@ -4958,33 +4965,29 @@ type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
+  attempt(...parameters: Parameters): Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
-   * @throws {PlanError<Yielded, Returned>}
+   * @throws {PlannedError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): PlanReturned<Returned>;
+  run(...parameters: Parameters): PlannedReturned<Returned>;
 };
-/**
- * An OK result of a plan execution
- */
-type PlanOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
-type PlanErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
 /**
  * An error result of a plan execution
  */
-type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+type PlannedError<Yielded, Returned> = [PlannedErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+type PlannedErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
 type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer E> ? E : Original extends Failure<infer E> ? E : never;
 /**
- * The returned result of a plan execution _(excluding errors, which are thrown)_
+ * An OK result of a plan execution
  */
-type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
+type PlannedOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
 /**
- * An immediately succeeding or failing plan
+ * The returned result of a plan execution _(excluding errors, which are thrown)_
  */
-type Planned<Value, Error> = Success<Value> | Failure<Error>;
+type PlannedReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
 /**
  * A single step within a plan of execution
  */
@@ -5184,7 +5187,7 @@ export declare namespace succeed {
  * @param signal Optional abort signal
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>>;
 /**
  * Attempt to run the generator to completion
  *
@@ -5194,7 +5197,7 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  * @param signal Optional abort signal
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -5205,7 +5208,7 @@ export declare function asyncAttemptRun<Yielded, Returned>(generator: () => Asyn
  * @param signal Optional abort signal
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -5215,7 +5218,7 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  * @param signal Optional abort signal
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>>;
 /**
  * Attempt to run the generator to completion
  *
@@ -5225,7 +5228,7 @@ export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yield
  * @param parameters Parameters for starting the run
  * @returns Result
  */
-export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -5235,7 +5238,7 @@ export declare function attemptRun<Yielded, Returned, Parameters extends unknown
  * @param parameters Parameters for starting the run
  * @returns Result
  */
-export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>;
 export declare namespace attemptRun {
   export var async: typeof asyncAttemptRun;
 }
@@ -5247,7 +5250,7 @@ export declare namespace attemptRun {
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run an asynchronous generator to completion
  *
@@ -5255,7 +5258,7 @@ export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
@@ -5264,7 +5267,7 @@ export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenera
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
@@ -5272,7 +5275,7 @@ export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run a generator to completion
  *
@@ -5280,7 +5283,7 @@ export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Ret
  * @param parameters Parameters for starting the run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlanReturned<Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlannedReturned<Returned>;
 /**
  * Run a plan to completion
  *
@@ -5288,7 +5291,7 @@ export declare function run<Yielded, Returned, Parameters extends unknown[]>(gen
  * @param parameters Parameters for starting the run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlannedReturned<Returned>;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;
 }
@@ -5397,12 +5400,6 @@ type PromiseParameters = {
  * - `first`: rejects on the first rejected _Promise_, and returns an array of values
  */
 type PromiseStrategy = "complete" | "first";
-/**
- * An error thrown when a promise times out
- */
-export declare class PromiseTimeoutError extends Error {
-  constructor();
-}
 type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
 /**
  * Options for handling multiple _Promises_
@@ -5434,6 +5431,12 @@ type RejectedPromise = {
    */
   reason: unknown;
 };
+/**
+ * An error thrown when a promise times out
+ */
+export declare class TimedError extends Error {
+  constructor();
+}
 declare const PROMISE_TYPE_FULFILLED = "fulfilled";
 declare const PROMISE_TYPE_REJECTED = "rejected";
 /**
@@ -7145,19 +7148,6 @@ type SubscriptionParameters = {
    */
   value: unknown;
 };
-/**
- * Property information for subscription identification
- */
-type SubscriptionProperty = {
-  /**
-   * Name of the property used to identify a subscription
-   */
-  key: string;
-  /**
-   * Value of the property used to identify a subscription
-   */
-  value: unknown;
-};
 type Subscriptions<Value = unknown> = {
   /**
    * Items of the subscriptions store
@@ -7195,10 +7185,6 @@ type SubscriptionsParameters = {
    * Allow any or specific keys for subscriptions? _(defaults to `false`, which prevents keyed subscriptions)_
    */
   keys?: boolean | Set<Key$1>;
-  /**
-   * Property information for subscription identification
-   */
-  property?: SubscriptionProperty;
 };
 type SubscriptionsItems = {
   any: Set<Subscription>;
@@ -7267,8 +7253,15 @@ type BeaconState<Value> = {
   observable?: Observable<Value>;
   options: Required<BeaconOptions<Value>>;
   subscriptions?: Subscriptions<Observer<unknown>>;
+  name: typeof BEACON_NAME;
   value: Value;
 };
+type InternalBeacon = {
+  [BEACON_SYMBOL]: BeaconState<unknown>;
+} & Beacon<unknown>;
+type InternalObservable = {
+  [BEACON_SYMBOL]: ObservableState<unknown>;
+} & Observable<unknown>;
 type Observable<Value> = {
   /**
    * Is the observable active?
@@ -7295,6 +7288,11 @@ type Observable<Value> = {
    */
   subscribe(observer: Observer<Value>): Subscription;
 };
+type ObservableState<Value> = {
+  active: boolean;
+  beacon: BeaconState<Value>;
+  name: typeof BEACON_OBSERVABLE;
+};
 type Observer<Value> = {
   /**
    * Callback for when the observable is completed
@@ -7309,29 +7307,11 @@ type Observer<Value> = {
    */
   next?: (value: Value) => void;
 };
-/**
- * Is the value a subscription?
- *
- * @param value Value to check
- * @returns `true` if the value is a subscription, otherwise `false`
- */
-export declare function isSubscription(value: unknown): value is Subscription;
-/**
- * Is the value a subscriptions store?
- *
- * @param value Value to check
- * @returns `true` if the value is a subscriptions store, otherwise `false`
- */
-export declare function isSubscriptions(value: unknown): value is Subscriptions;
-/**
- * Create a subscription store
- *
- * @param parameters Store parameters
- * @returns Subscription store
- */
-export declare function subscriptions<Value = unknown>(parameters?: SubscriptionsParameters): Subscriptions<Value>;
-declare function Beacon(this: any, value: unknown, options?: BeaconOptions<unknown>): void;
-declare function Observable(this: any, beacon: BeaconState<unknown>): void;
+declare const BEACON_NAME = "beacon";
+declare const BEACON_OBSERVABLE = "observable";
+declare const BEACON_SYMBOL: unique symbol;
+declare function Beacon(this: InternalBeacon, value: unknown, options?: BeaconOptions<unknown>): void;
+declare function Observable(this: InternalObservable, beacon: BeaconState<unknown>): void;
 /**
  * Create a new beacon
  *
@@ -7347,13 +7327,6 @@ export declare function beacon<Value>(value: Value, options?: BeaconOptions<Valu
  * @returns `true` if the value is a beacon, otherwise `false`
  */
 export declare function isBeacon<Value = unknown>(value: unknown): value is Beacon<Value>;
-/**
- * Is the value a beacon subscription?
- *
- * @param value Value to check
- * @returns `true` if the value is a beacon subscription, otherwise `false`
- */
-export declare function isBeaconSubscription(value: unknown): value is Subscription;
 /**
  * Is the value an observable?
  *
@@ -7395,7 +7368,6 @@ type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in ke
 type HeraldOnCreate<Events extends Record<string, GenericCallback>> = <Event extends keyof Events>(event: Event, callback: Events[Event], subscription: Subscription) => void;
 type HeraldOptions<Events extends Record<string, GenericCallback>> = {
   names: Array<keyof Events>;
-  property?: SubscriptionProperty;
   onCreate?: HeraldOnCreate<Events>;
 };
 /**
@@ -8089,13 +8061,6 @@ export declare function isHerald<Events extends Record<string, GenericCallback>
  * @returns `true` if the value is events for a herald, otherwise `false`
  */
 export declare function isHeraldEvents<Events extends Record<string, GenericCallback> = Record<string, GenericCallback>>(value: unknown): value is HeraldEvents<Events>;
-/**
- * Is the value a herald subscription?
- *
- * @param value Value to check
- * @returns `true` if the value is a herald subscription, otherwise `false`
- */
-export declare function isHeraldSubscription(value: unknown): value is Subscription;
 /**
  * Is the value an array or a plain object?
  *
@@ -9188,6 +9153,9 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
    * Is the _Set_ full?
    */
   get full(): boolean;
+  /**
+   * The maximum size of the _Set_
+   */
   get maximum(): number;
   /**
    * Create a new _SizedSet_ with values and a maximum size _(2^20)_
@@ -9224,4 +9192,25 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
    */
   get(value: Value, update?: boolean): Value | undefined;
 }
-export { type ArrayComparisonSorter, type ArrayKeySorter, type ArrayKeySorters, type ArraySorter, type ArraySorters, type ArrayValueSorter, type Asserter, type AssignOptions, type Assigner, type AsyncFailure, type AsyncFlow, type AsyncLimiter, type AsyncOnce, type AsyncPlan, type AsyncPlanned, type AsyncStep, type AsyncSuccess, type Beacon, type BeaconOptions, type CloneOptions, type Cloner, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type CompareCallback, type ComparisonSorter, type DiffOptions, type DiffResult, type EqualOptions, type Equalizer, type Failure, type Flow, type FulfilledPromise, type Fuzzy, type FuzzyOptions, type FuzzyResult, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, type Herald, type HeraldEvents, type HeraldOptions, Key$1 as Key, type KeyedQueue, type Limiter, Logger, type Memoized, type MemoizedOptions, type MergeOptions, type Merger, type NormalizeOptions, type Normalizer, type Observable, type Observer, type Once, type Plan, type PlanError, type PlanOk, type PlanReturned, type Planned, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type Queue, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, type Renderer, type Shaken, type Smushed, type SortDirection, type Sorter, type Step, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type Success, type TemplateOptions, type Templater, type TemplaterOptions, type TemplaterRenderer, type TimeLogger, type TransformCallback, type TransformCallbacks, type Transformer, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };
+/**
+ * Is the value a subscription?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a subscription, otherwise `false`
+ */
+export declare function isSubscription(value: unknown): value is Subscription;
+/**
+ * Is the value a subscriptions store?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a subscriptions store, otherwise `false`
+ */
+export declare function isSubscriptions(value: unknown): value is Subscriptions;
+/**
+ * Create a subscription store
+ *
+ * @param parameters Store parameters
+ * @returns Subscription store
+ */
+export declare function subscriptions<Value = unknown>(parameters?: SubscriptionsParameters): Subscriptions<Value>;
+export { type ArrayComparisonSorter, type ArrayKeySorter, type ArrayKeySorters, type ArraySorter, type ArraySorters, type ArrayValueSorter, type Asserter, type AssignOptions, type Assigner, type AsyncFailure, type AsyncFlow, type AsyncImmediate, type AsyncLimiter, type AsyncOnce, type AsyncPlan, type AsyncStep, type AsyncSuccess, type Beacon, type BeaconOptions, type CloneOptions, type Cloner, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type CompareCallback, type ComparisonSorter, type DiffOptions, type DiffResult, type EqualOptions, type Equalizer, type Failure, type Flow, type FulfilledPromise, type Fuzzy, type FuzzyOptions, type FuzzyResult, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, type Herald, type HeraldEvents, type HeraldOptions, type Immediate, Key$1 as Key, type KeyedQueue, type Limiter, Logger, type Memoized, type MemoizedOptions, type MergeOptions, type Merger, type NormalizeOptions, type Normalizer, type Observable, type Observer, type Once, type Plan, type PlannedError, type PlannedOk, type PlannedReturned, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type Queue, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, type Renderer, type Shaken, type Smushed, type SortDirection, type Sorter, type Step, type Subscription, type SubscriptionParameters, type Subscriptions, type SubscriptionsParameters, type Success, type TemplateOptions, type Templater, type TemplaterOptions, type TemplaterRenderer, type TimeLogger, type TransformCallback, type TransformCallbacks, type Transformer, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };