atom.io 0.19.3 → 0.20.0

package/internal/src/transaction/create-transaction.ts

@@ -1,13 +1,13 @@
 import type {
+	Func,
 	TransactionOptions,
 	TransactionToken,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
 
 import { newest } from "../lineage"
-import { deposit } from "../store"
 import type { Store } from "../store"
+import { deposit } from "../store"
 import { Subject } from "../subject"
 import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"

package/internal/src/transaction/index.ts

@@ -1,4 +1,4 @@
-import type { TransactionUpdate, TransactorsWithRunAndEnv, Func } from "atom.io"
+import type { Func, TransactionUpdate, TransactorsWithRunAndEnv } from "atom.io"
 import type { Junction } from "rel8/junction"
 
 export * from "./abort-transaction"

package/internal/src/transaction/is-root-store.ts

@@ -1,7 +1,7 @@
 import type { Func } from "atom.io"
 
-import type { TransactionEpoch, TransactionProgress } from "."
 import type { Store } from "../store"
+import type { TransactionEpoch, TransactionProgress } from "."
 
 export interface RootStore extends Store {
 	transactionMeta: TransactionEpoch

package/introspection/src/attach-atom-index.ts

@@ -1,9 +1,9 @@
 import type { AtomToken, ReadonlySelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 	newest,
 } from "atom.io/internal"
 

package/introspection/src/attach-introspection-states.ts

@@ -1,14 +1,14 @@
 import type {
+	Func,
 	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
-import * as Internal from "atom.io/internal"
 import type { Timeline } from "atom.io/internal"
+import * as Internal from "atom.io/internal"
 
 import { type AtomTokenIndex, attachAtomIndex } from "./attach-atom-index"
 import type { SelectorTokenIndex } from "./attach-selector-index"

package/introspection/src/attach-selector-index.ts

@@ -1,9 +1,9 @@
 import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 	newest,
 } from "atom.io/internal"
 

package/introspection/src/attach-timeline-family.ts

@@ -4,10 +4,10 @@ import type {
 } from "atom.io"
 import type { Store, Timeline } from "atom.io/internal"
 import {
-	IMPLICIT,
-	Subject,
 	createRegularAtomFamily,
 	createSelectorFamily,
+	IMPLICIT,
+	Subject,
 } from "atom.io/internal"
 
 export const attachTimelineFamily = (

package/introspection/src/attach-timeline-index.ts

@@ -1,9 +1,9 @@
 import type { ReadonlySelectorToken, TimelineToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 } from "atom.io/internal"
 
 export const attachTimelineIndex = (

package/introspection/src/attach-transaction-index.ts

@@ -1,9 +1,9 @@
-import type { ReadonlySelectorToken, TransactionToken, Func } from "atom.io"
+import type { Func, ReadonlySelectorToken, TransactionToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 } from "atom.io/internal"
 
 export const attachTransactionIndex = (

package/introspection/src/attach-transaction-logs.ts

@@ -1,13 +1,13 @@
 import type {
+	Func,
 	ReadonlySelectorFamilyToken,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtomFamily,
 	createSelectorFamily,
+	IMPLICIT,
 } from "atom.io/internal"
 
 export const attachTransactionLogs = (

package/json/dist/index.cjs

@@ -2,6 +2,41 @@
 
 var internal = require('atom.io/internal');
 
+// json/src/select-json.ts
+var selectJson = (atom, transform, store = internal.IMPLICIT.STORE) => {
+  return internal.createStandaloneSelector(
+    {
+      key: `${atom.key}:JSON`,
+      get: ({ get }) => transform.toJson(get(atom)),
+      set: ({ set }, newValue) => {
+        set(atom, transform.fromJson(newValue));
+      }
+    },
+    store
+  );
+};
+function selectJsonFamily(family, transform, store = internal.IMPLICIT.STORE) {
+  const jsonFamily = internal.createSelectorFamily(
+    {
+      key: `${family.key}:JSON`,
+      get: (key) => ({ get }) => transform.toJson(get(family(key))),
+      set: (key) => ({ set }, newValue) => {
+        set(family(key), transform.fromJson(newValue));
+      }
+    },
+    store
+  );
+  family.subject.subscribe(
+    `store=${store.config.name}::json-selector-family`,
+    (token) => {
+      if (token.family) {
+        jsonFamily(parseJson(token.family.subKey));
+      }
+    }
+  );
+  return jsonFamily;
+}
+
 // ../anvl/src/json/json-interface.ts
 var stringSetJsonInterface = {
   toJson: (stringSet) => Array.from(stringSet),
@@ -44,39 +79,6 @@ var isNull = (input) => {
 var isPrimitive = (input) => {
   return isString(input) || isNumber(input) || isBoolean(input) || isNull(input);
 };
-var selectJson = (atom, transform, store = internal.IMPLICIT.STORE) => {
-  return internal.createStandaloneSelector(
-    {
-      key: `${atom.key}:JSON`,
-      get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => {
-        set(atom, transform.fromJson(newValue));
-      }
-    },
-    store
-  );
-};
-function selectJsonFamily(atomFamily, transform, store = internal.IMPLICIT.STORE) {
-  const jsonFamily = internal.createSelectorFamily(
-    {
-      key: `${atomFamily.key}:JSON`,
-      get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
-      set: (key) => ({ set }, newValue) => {
-        set(atomFamily(key), transform.fromJson(newValue));
-      }
-    },
-    store
-  );
-  atomFamily.subject.subscribe(
-    `store=${store.config.name}::json-selector-family`,
-    (token) => {
-      if (token.family) {
-        jsonFamily(parseJson(token.family.subKey));
-      }
-    }
-  );
-  return jsonFamily;
-}
 
 exports.JSON_DEFAULTS = JSON_DEFAULTS;
 exports.JSON_TYPE_NAMES = JSON_TYPE_NAMES;

package/json/dist/index.d.ts

@@ -1,6 +1,11 @@
 import * as AtomIO from 'atom.io';
 import { Store, Transceiver } from 'atom.io/internal';
 
+declare const selectJson: <T, J extends Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.WritableSelectorToken<J>;
+
+declare function selectJsonFamily<T extends Transceiver<any>, J extends Serializable, K extends Serializable>(atomFamily: AtomIO.MutableAtomFamily<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
+declare function selectJsonFamily<T, J extends Serializable, K extends Serializable>(atomFamily: AtomIO.RegularAtomFamily<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
+
 type JsonInterface<T, J extends Serializable = Serializable> = {
     toJson: (t: T) => J;
     fromJson: (json: J) => T;
@@ -44,11 +49,6 @@ interface JsonTypes extends Record<JsonTypeName, Serializable> {
 }
 declare const JSON_DEFAULTS: JsonTypes;
 
-declare const selectJson: <T, J extends Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.WritableSelectorToken<J>;
-
-declare function selectJsonFamily<T extends Transceiver<any>, J extends Serializable, K extends Serializable>(atomFamily: AtomIO.MutableAtomFamily<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
-declare function selectJsonFamily<T, J extends Serializable, K extends Serializable>(atomFamily: AtomIO.RegularAtomFamily<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
-
 type JsonIO = (...params: Serializable[]) => Serializable | void;
 
 export { type Empty, JSON_DEFAULTS, JSON_TYPE_NAMES, json as Json, type JsonIO, type JsonInterface, type JsonTypeName, type JsonTypes, type Stringified, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, type primitive, selectJson, selectJsonFamily, stringSetJsonInterface, stringifyJson };

package/json/dist/index.js

@@ -15,18 +15,18 @@ var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
     store
   );
 };
-function selectJsonFamily(atomFamily, transform, store = IMPLICIT.STORE) {
+function selectJsonFamily(family, transform, store = IMPLICIT.STORE) {
   const jsonFamily = createSelectorFamily(
     {
-      key: `${atomFamily.key}:JSON`,
-      get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
+      key: `${family.key}:JSON`,
+      get: (key) => ({ get }) => transform.toJson(get(family(key))),
       set: (key) => ({ set }, newValue) => {
-        set(atomFamily(key), transform.fromJson(newValue));
+        set(family(key), transform.fromJson(newValue));
       }
     },
     store
   );
-  atomFamily.subject.subscribe(
+  family.subject.subscribe(
     `store=${store.config.name}::json-selector-family`,
     (token) => {
       if (token.family) {

package/json/src/index.ts

@@ -1,8 +1,7 @@
-export * from "~/packages/anvl/src/json"
-export * from "~/packages/anvl/src/primitive"
-
 export * from "./select-json"
 export * from "./select-json-family"
+export * from "~/packages/anvl/src/json"
+export * from "~/packages/anvl/src/primitive"
 
 import type { Json } from "~/packages/anvl/src/json"
 

package/json/src/select-json-family.ts

@@ -1,6 +1,6 @@
 import type * as AtomIO from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
-import { IMPLICIT, createSelectorFamily } from "atom.io/internal"
+import { createSelectorFamily, IMPLICIT } from "atom.io/internal"
 
 import type { Json, JsonInterface } from "."
 import { parseJson } from "."
@@ -28,7 +28,7 @@ export function selectJsonFamily<
 	J extends Json.Serializable,
 	K extends Json.Serializable,
 >(
-	atomFamily:
+	family:
 		| AtomIO.MutableAtomFamily<T extends Transceiver<any> ? T : never, J, K>
 		| AtomIO.RegularAtomFamily<T, K>,
 	transform: JsonInterface<T, J>,
@@ -36,20 +36,20 @@ export function selectJsonFamily<
 ): AtomIO.WritableSelectorFamily<J, K> {
 	const jsonFamily = createSelectorFamily<J, K>(
 		{
-			key: `${atomFamily.key}:JSON`,
+			key: `${family.key}:JSON`,
 			get:
 				(key) =>
 				({ get }) =>
-					transform.toJson(get(atomFamily(key))),
+					transform.toJson(get(family(key))),
 			set:
 				(key) =>
 				({ set }, newValue) => {
-					set(atomFamily(key), transform.fromJson(newValue))
+					set(family(key), transform.fromJson(newValue))
 				},
 		},
 		store,
 	)
-	atomFamily.subject.subscribe(
+	family.subject.subscribe(
 		`store=${store.config.name}::json-selector-family`,
 		(token) => {
 			if (token.family) {

package/json/src/select-json.ts

@@ -1,8 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
-import { IMPLICIT } from "atom.io/internal"
+import { createStandaloneSelector, IMPLICIT } from "atom.io/internal"
 
-import { createStandaloneSelector } from "atom.io/internal"
 import type { Json, JsonInterface } from "."
 
 export const selectJson = <T, J extends Json.Serializable>(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.19.3",
+  "version": "0.20.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -48,21 +48,24 @@
     }
   },
   "devDependencies": {
-    "@testing-library/react": "15.0.2",
-    "@types/eslint": "8.56.9",
+    "@testing-library/react": "15.0.4",
+    "@types/eslint": "npm:@types/eslint@8.56.10",
+    "@types/eslint-v9": "npm:@types/eslint@8.56.10",
     "@types/estree": "1.0.5",
     "@types/http-proxy": "1.17.14",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.2.78",
+    "@types/react": "18.2.79",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "7.7.0",
-    "@vitest/coverage-v8": "1.5.0",
-    "@vitest/ui": "1.5.0",
+    "@typescript-eslint/parser": "7.7.1",
+    "@typescript-eslint/rule-tester": "7.7.1",
+    "@vitest/coverage-v8": "1.5.1",
+    "@vitest/ui": "1.5.1",
     "concurrently": "8.2.2",
-    "drizzle-kit": "0.20.14",
-    "drizzle-orm": "0.30.8",
-    "eslint": "9.0.0",
-    "framer-motion": "11.0.28",
+    "drizzle-kit": "0.20.17",
+    "drizzle-orm": "0.30.9",
+    "eslint": "npm:eslint@8.57.0",
+    "eslint-v9": "npm:eslint@9.1.1",
+    "framer-motion": "11.1.7",
     "happy-dom": "14.7.1",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
@@ -70,15 +73,15 @@
     "preact": "10.20.2",
     "react": "18.2.0",
     "react-dom": "18.2.0",
-    "react-router-dom": "6.22.3",
+    "react-router-dom": "6.23.0",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
     "tsup": "8.0.2",
     "typescript": "5.4.5",
-    "vite": "5.2.8",
+    "vite": "5.2.10",
     "vite-tsconfig-paths": "4.3.2",
-    "vitest": "1.5.0"
+    "vitest": "1.5.1"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -245,7 +248,7 @@
     "build:realtime-testing": "cd realtime-testing && tsup",
     "build:transceivers:set-rtx": "cd transceivers/set-rtx && tsup",
     "lint:biome": "biome check -- .",
-    "lint:eslint": "eslint . --ignore-pattern={**/dist/**,**/coverage/**}",
+    "lint:eslint": "eslint .",
     "lint:eslint:build": "bun run build:main",
     "lint:types": "tsc --noEmit",
     "lint": "bun run lint:biome && bun run lint:eslint && bun run lint:types",

package/react/src/use-tl.ts

@@ -1,5 +1,5 @@
-import { redo, undo } from "atom.io"
 import type { TimelineToken } from "atom.io"
+import { redo, undo } from "atom.io"
 import { subscribeToTimeline, withdraw } from "atom.io/internal"
 import * as React from "react"
 

package/react-devtools/dist/index.cjs

@@ -40,6 +40,12 @@ var __objRest = (source, exclude) => {
   return target;
 };
 
+// ../anvl/src/array/index.ts
+var isArray = (isType) => (input) => Array.isArray(input) && input.every((item) => isType(item));
+var map = (f) => (a) => a.map(f);
+var every = (f = Boolean) => (a) => a.every(f);
+var allTrue = every((x) => x === true);
+
 // ../anvl/src/function/pipe.ts
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
@@ -88,12 +94,6 @@ var fallback = (fn, fallbackValue) => {
   }
 };
 
-// ../anvl/src/array/index.ts
-var isArray = (isType) => (input) => Array.isArray(input) && input.every((item) => isType(item));
-var map = (f) => (a) => a.map(f);
-var every = (f = Boolean) => (a) => a.every(f);
-var allTrue = every((x) => x === true);
-
 // ../anvl/src/nullish/index.ts
 var isUndefined = (input) => input === void 0;
 var ifDefined = (validate) => (input) => isUndefined(input) || validate(input);
@@ -181,50 +181,59 @@ var delve = (obj, path) => {
   return found === void 0 ? new Error(`Not found`) : { found };
 };
 
-// ../anvl/src/refinement/refinery.ts
-var Refinery = class {
-  constructor(supported) {
-    this.supported = supported;
-  }
-  refine(input) {
-    for (const [key, refiner] of Object.entries(this.supported)) {
-      try {
-        if (
-          // @ts-expect-error that's the point
-          refiner(input) === true && refiner !== Boolean
-        ) {
-          return { type: key, data: input };
-        }
-      } catch (e) {
-        try {
-          if (input instanceof refiner) {
-            return { type: key, data: input };
-          }
-        } catch (_) {
-        }
+// ../anvl/src/refinement/can-exist.ts
+var canExist = (_) => true;
+
+// ../anvl/src/refinement/cannot-exist.ts
+var cannotExist = (_) => false;
+
+// ../anvl/src/refinement/is-intersection.ts
+function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [isTypeA]) {
+  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` & `)})`;
+  const _ = {
+    [name]: (input) => refinements.every(
+      (refinement) => (logging && console.log(
+        refinements.map((r) => r.name || `anon`).join(` & `),
+        `>`,
+        refinement.name || `anon`,
+        `:`,
+        refinement(input)
+      ), refinement(input))
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    and: (isTypeB) => mustSatisfyAllOfTheFollowing(isTypeB, logging, [
+      ...refinements,
+      isTypeB
+    ])
+  });
+  return checkTypes;
+}
+var isIntersection = mustSatisfyAllOfTheFollowing(canExist);
+
+// ../anvl/src/refinement/is-union.ts
+var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` | `)})`;
+  const _ = {
+    [name]: (input) => refinements.some(
+      (refinement) => {
+        var _a;
+        return logging && console.log(
+          refinements.map((r) => r.name || `anon`).join(` | `),
+          `>`,
+          (_a = refinement.name) != null ? _a : `anon`,
+          `:`,
+          refinement(input)
+        ), refinement(input);
       }
-    }
-    return null;
-  }
-};
-var jsonRefinery = new Refinery({
-  number: (input) => typeof input === `number`,
-  string: (input) => typeof input === `string`,
-  boolean: (input) => typeof input === `boolean`,
-  object: isPlainObject,
-  array: (input) => Array.isArray(input),
-  null: (input) => input === null
-});
-var discoverType = (input) => {
-  if (input === void 0) {
-    return `undefined`;
-  }
-  const refined = jsonRefinery.refine(input);
-  if (refined) {
-    return refined.type;
-  }
-  return Object.getPrototypeOf(input).constructor.name;
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    or: (isTypeB) => mustSatisfyOneOfTheFollowing(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
 };
+var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
 
 // ../anvl/src/json/index.ts
 var stringifyJson = (json) => JSON.stringify(json);
@@ -278,59 +287,50 @@ var isJson = (input) => {
   return refine;
 };
 
-// ../anvl/src/refinement/can-exist.ts
-var canExist = (_) => true;
-
-// ../anvl/src/refinement/cannot-exist.ts
-var cannotExist = (_) => false;
-
-// ../anvl/src/refinement/is-union.ts
-var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isTypeA]) => {
-  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` | `)})`;
-  const _ = {
-    [name]: (input) => refinements.some(
-      (refinement) => {
-        var _a;
-        return logging && console.log(
-          refinements.map((r) => r.name || `anon`).join(` | `),
-          `>`,
-          (_a = refinement.name) != null ? _a : `anon`,
-          `:`,
-          refinement(input)
-        ), refinement(input);
+// ../anvl/src/refinement/refinery.ts
+var Refinery = class {
+  constructor(supported) {
+    this.supported = supported;
+  }
+  refine(input) {
+    for (const [key, refiner] of Object.entries(this.supported)) {
+      try {
+        if (
+          // @ts-expect-error that's the point
+          refiner(input) === true && refiner !== Boolean
+        ) {
+          return { type: key, data: input };
+        }
+      } catch (e) {
+        try {
+          if (input instanceof refiner) {
+            return { type: key, data: input };
+          }
+        } catch (_) {
+        }
       }
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    or: (isTypeB) => mustSatisfyOneOfTheFollowing(isTypeB, logging, [...refinements, isTypeB])
-  });
-  return checkTypes;
+    }
+    return null;
+  }
+};
+var jsonRefinery = new Refinery({
+  number: (input) => typeof input === `number`,
+  string: (input) => typeof input === `string`,
+  boolean: (input) => typeof input === `boolean`,
+  object: isPlainObject,
+  array: (input) => Array.isArray(input),
+  null: (input) => input === null
+});
+var discoverType = (input) => {
+  if (input === void 0) {
+    return `undefined`;
+  }
+  const refined = jsonRefinery.refine(input);
+  if (refined) {
+    return refined.type;
+  }
+  return Object.getPrototypeOf(input).constructor.name;
 };
-var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
-
-// ../anvl/src/refinement/is-intersection.ts
-function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [isTypeA]) {
-  const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` & `)})`;
-  const _ = {
-    [name]: (input) => refinements.every(
-      (refinement) => (logging && console.log(
-        refinements.map((r) => r.name || `anon`).join(` & `),
-        `>`,
-        refinement.name || `anon`,
-        `:`,
-        refinement(input)
-      ), refinement(input))
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    and: (isTypeB) => mustSatisfyAllOfTheFollowing(isTypeB, logging, [
-      ...refinements,
-      isTypeB
-    ])
-  });
-  return checkTypes;
-}
-var isIntersection = mustSatisfyAllOfTheFollowing(canExist);
 
 // ../anvl/src/refinement/index.ts
 var isLiteral = (value) => (input) => input === value;

package/react-devtools/dist/index.css

@@ -131,9 +131,6 @@ main.atom_io_devtools {
       }
       section.transaction_log {
         margin-top: 0;
-        header: {
-          padding: 5px;
-        }
         main {
           display: flex;
           flex-flow: row wrap;

package/react-devtools/dist/index.d.ts

@@ -4,6 +4,8 @@ import { AtomToken, ReadonlySelectorToken, WritableSelectorToken } from 'atom.io
 
 type ClassSignature = abstract new (...args: any) => any;
 
+type Refinement<A, B extends A> = (a: A) => a is B;
+
 type RefinementStrategy = ClassSignature | Refinement<unknown, any>;
 type Supported<Refine extends RefinementStrategy> = Refine extends Refinement<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
 type RefinementSupport = Record<string, RefinementStrategy>;
@@ -18,8 +20,6 @@ declare class Refinery<SupportedTypes extends RefinementSupport> {
     }[keyof SupportedTypes] | null;
 }
 
-type Refinement<A, B extends A> = (a: A) => a is B;
-
 type PlainObject = Record<keyof any, unknown>;
 
 type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;