@fluidframework/core-interfaces 2.90.0-378676 → 2.91.0

package/src/exposedInternalUtilityTypes.ts

@@ -134,20 +134,18 @@ export namespace InternalUtilityTypes {
 	 *
 	 * @system
 	 */
-	export type OptionalNonSymbolKeysOf<
-		T extends object,
-		Keys extends keyof T = keyof T,
-	> = Exclude<
-		{
-			[K in Keys]: T extends Record<K, T[K]> ? never : K;
-		}[Keys],
-		undefined | symbol
-	> extends infer Result
-		? //   Workaround for TypeScript bug/limitation where an alias for a type
-			// is not considered the same type when used as an index. This restores
-			// the original `Keys` (`keyof T`) type when there is no filtering.
-			IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
-		: never;
+	export type OptionalNonSymbolKeysOf<T extends object, Keys extends keyof T = keyof T> =
+		Exclude<
+			{
+				[K in Keys]: T extends Record<K, T[K]> ? never : K;
+			}[Keys],
+			undefined | symbol
+		> extends infer Result
+			? //   Workaround for TypeScript bug/limitation where an alias for a type
+				// is not considered the same type when used as an index. This restores
+				// the original `Keys` (`keyof T`) type when there is no filtering.
+				IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
+			: never;
 
 	/**
 	 * Returns non-symbol keys for required properties of an object type.
@@ -158,20 +156,18 @@ export namespace InternalUtilityTypes {
 	 *
 	 * @system
 	 */
-	export type RequiredNonSymbolKeysOf<
-		T extends object,
-		Keys extends keyof T = keyof T,
-	> = Exclude<
-		{
-			[K in Keys]: T extends Record<K, T[K]> ? K : never;
-		}[Keys],
-		undefined | symbol
-	> extends infer Result
-		? //   Workaround for TypeScript bug/limitation where an alias for a type
-			// is not considered the same type when used as an index. This restores
-			// the original `Keys` (`keyof T`) type when there is no filtering.
-			IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
-		: never;
+	export type RequiredNonSymbolKeysOf<T extends object, Keys extends keyof T = keyof T> =
+		Exclude<
+			{
+				[K in Keys]: T extends Record<K, T[K]> ? K : never;
+			}[Keys],
+			undefined | symbol
+		> extends infer Result
+			? //   Workaround for TypeScript bug/limitation where an alias for a type
+				// is not considered the same type when used as an index. This restores
+				// the original `Keys` (`keyof T`) type when there is no filtering.
+				IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
+			: never;
 
 	/**
 	 * Returns Result.WhenSomethingDeserializable if T is sometimes at least a
@@ -289,58 +285,59 @@ export namespace InternalUtilityTypes {
 		TExactExceptions extends unknown[],
 		TExtendsException,
 		Keys extends keyof T = keyof T,
-	> = Exclude<
-		{
-			[K in Keys]: /* all possible types that aren't already allowed, with the exception of `unknown` */
-			ExcludeExactlyInTuple<
-				Exclude<T[K], TExtendsException>,
-				OmitExactlyFromTuple<TExactExceptions, unknown>
-			> extends infer PossibleTypeLessAllowed
-				? IfSameType<
-						PossibleTypeLessAllowed,
-						unknown,
-						/* value might not be supported => check for indexed key */ IfIndexOrBrandedKey<
-							K,
-							/* indexed => allow K */ K,
-							/* literal => exclude K */ never
-						>,
-						/* extract types that might lead to missing property */ Extract<
+	> =
+		Exclude<
+			{
+				[K in Keys]: /* all possible types that aren't already allowed, with the exception of `unknown` */
+				ExcludeExactlyInTuple<
+					Exclude<T[K], TExtendsException>,
+					OmitExactlyFromTuple<TExactExceptions, unknown>
+				> extends infer PossibleTypeLessAllowed
+					? IfSameType<
 							PossibleTypeLessAllowed,
-							/* types that might lead to missing property, except `bigint` */
-							// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-							undefined | symbol | Function
-						> extends never
-							? /* all types are supported plus possibly `bigint` => */
-								/* check for only `bigint` remaining */ IfSameType<
-									PossibleTypeLessAllowed,
-									bigint,
-									/* only `bigint` => nothing supported */ never,
-									/* exclusively supported types (and maybe `bigint`) or exactly `never` */
-									/* => check for `never` */ T[K] extends never ? never : K
-								>
-							: /* value might not be supported => check for any supported */ TestDeserializabilityOf<
-									T[K],
-									OmitExactlyFromTuple<TExactExceptions, unknown>,
-									TExtendsException,
-									{
-										WhenSomethingDeserializable: /* => check for indexed key */ IfIndexOrBrandedKey<
-											K,
-											/* indexed => allow K */ K,
-											/* literal => exclude K */ never
-										>;
-										WhenNeverDeserializable: /* => exclude K */ never;
-									}
-								>
-					>
-				: never;
-		}[Keys],
-		undefined | symbol
-	> extends infer Result
-		? //   Workaround for TypeScript bug/limitation where an alias for a type
-			// is not considered the same type when used as an index. This restores
-			// the original `Keys` (`keyof T`) type when there is no filtering.
-			IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
-		: never;
+							unknown,
+							/* value might not be supported => check for indexed key */ IfIndexOrBrandedKey<
+								K,
+								/* indexed => allow K */ K,
+								/* literal => exclude K */ never
+							>,
+							/* extract types that might lead to missing property */ Extract<
+								PossibleTypeLessAllowed,
+								/* types that might lead to missing property, except `bigint` */
+								// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+								undefined | symbol | Function
+							> extends never
+								? /* all types are supported plus possibly `bigint` => */
+									/* check for only `bigint` remaining */ IfSameType<
+										PossibleTypeLessAllowed,
+										bigint,
+										/* only `bigint` => nothing supported */ never,
+										/* exclusively supported types (and maybe `bigint`) or exactly `never` */
+										/* => check for `never` */ T[K] extends never ? never : K
+									>
+								: /* value might not be supported => check for any supported */ TestDeserializabilityOf<
+										T[K],
+										OmitExactlyFromTuple<TExactExceptions, unknown>,
+										TExtendsException,
+										{
+											WhenSomethingDeserializable: /* => check for indexed key */ IfIndexOrBrandedKey<
+												K,
+												/* indexed => allow K */ K,
+												/* literal => exclude K */ never
+											>;
+											WhenNeverDeserializable: /* => exclude K */ never;
+										}
+									>
+						>
+					: never;
+			}[Keys],
+			undefined | symbol
+		> extends infer Result
+			? //   Workaround for TypeScript bug/limitation where an alias for a type
+				// is not considered the same type when used as an index. This restores
+				// the original `Keys` (`keyof T`) type when there is no filtering.
+				IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
+			: never;
 
 	/**
 	 * Returns non-symbol, literal keys for partially supported properties of an object type.
@@ -357,43 +354,49 @@ export namespace InternalUtilityTypes {
 		TExactExceptions extends unknown[],
 		TExtendsException,
 		Keys extends keyof T = keyof T,
-	> = Exclude<
-		{
-			[K in Keys]: IfIndexOrBrandedKey<
-				K,
-				/* indexed => exclude K */ never,
-				/* literal => ... */
-				/* all possible types that aren't already allowed, with the exception of `unknown` */
-				ExcludeExactlyInTuple<
-					Exclude<T[K], TExtendsException>,
-					OmitExactlyFromTuple<TExactExceptions, unknown>
-				> extends infer PossibleTypeLessAllowed
-					? Extract<
-							IfSameType<PossibleTypeLessAllowed, unknown, undefined, PossibleTypeLessAllowed>,
-							/* types that might lead to missing property */
-							// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-							undefined | symbol | Function
-						> extends never
-						? /* exclusively supported types or exactly `never` */ never
-						: /* at least some unsupported type => check for any supported */ TestDeserializabilityOf<
-								T[K],
-								OmitExactlyFromTuple<TExactExceptions, unknown>,
-								TExtendsException,
-								{
-									WhenSomethingDeserializable: K;
-									WhenNeverDeserializable: never;
-								}
-							>
-					: never
-			>;
-		}[Keys],
-		undefined | symbol
-	> extends infer Result
-		? //   Workaround for TypeScript bug/limitation where an alias for a type
-			// is not considered the same type when used as an index. This restores
-			// the original `Keys` (`keyof T`) type when there is no filtering.
-			IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
-		: never;
+	> =
+		Exclude<
+			{
+				[K in Keys]: IfIndexOrBrandedKey<
+					K,
+					/* indexed => exclude K */ never,
+					/* literal => ... */
+					/* all possible types that aren't already allowed, with the exception of `unknown` */
+					ExcludeExactlyInTuple<
+						Exclude<T[K], TExtendsException>,
+						OmitExactlyFromTuple<TExactExceptions, unknown>
+					> extends infer PossibleTypeLessAllowed
+						? Extract<
+								IfSameType<
+									PossibleTypeLessAllowed,
+									unknown,
+									undefined,
+									PossibleTypeLessAllowed
+								>,
+								/* types that might lead to missing property */
+								// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+								undefined | symbol | Function
+							> extends never
+							? /* exclusively supported types or exactly `never` */ never
+							: /* at least some unsupported type => check for any supported */ TestDeserializabilityOf<
+									T[K],
+									OmitExactlyFromTuple<TExactExceptions, unknown>,
+									TExtendsException,
+									{
+										WhenSomethingDeserializable: K;
+										WhenNeverDeserializable: never;
+									}
+								>
+						: never
+				>;
+			}[Keys],
+			undefined | symbol
+		> extends infer Result
+			? //   Workaround for TypeScript bug/limitation where an alias for a type
+				// is not considered the same type when used as an index. This restores
+				// the original `Keys` (`keyof T`) type when there is no filtering.
+				IfSameType<Keys, Result, Keys, Extract<Result, string | number>>
+			: never;
 
 	/**
 	 * Filters a type `T` for `undefined` that is not viable in an array (or tuple) that
@@ -408,32 +411,33 @@ export namespace InternalUtilityTypes {
 		Controls extends FilterControls,
 		TAncestorTypes extends unknown[],
 		TBlessed,
-	> = /* Some initial filtering must be provided before a test for undefined. */
-	/* These tests are expected to match those in JsonSerializableImpl. */
-	/* test for 'any' */ boolean extends (T extends never ? true : false)
-		? /* 'any' => */ TBlessed
-		: /* test for 'unknown' */ unknown extends T
-			? /* 'unknown' => */ TBlessed
-			: /* test for exact recursion */ IfExactTypeInTuple<
-					T,
-					TAncestorTypes,
-					/* recursion; stop here => */ T,
-					/* test for JSON primitive types or given alternative */ T extends
-						| null
-						| boolean
-						| number
-						| string
-						| Controls["AllowExtensionOf"]
-						? /* primitive types or alternative => */ T
-						: /* test for exact alternative */ IfExactTypeInTuple<
-								T,
-								Controls["AllowExactly"],
-								T,
-								/* test for undefined possibility */ undefined extends T
-									? /* undefined | ... => */ SerializationErrorPerUndefinedArrayElement
-									: TBlessed
-							>
-				>;
+	> =
+		/* Some initial filtering must be provided before a test for undefined. */
+		/* These tests are expected to match those in JsonSerializableImpl. */
+		/* test for 'any' */ boolean extends (T extends never ? true : false)
+			? /* 'any' => */ TBlessed
+			: /* test for 'unknown' */ unknown extends T
+				? /* 'unknown' => */ TBlessed
+				: /* test for exact recursion */ IfExactTypeInTuple<
+						T,
+						TAncestorTypes,
+						/* recursion; stop here => */ T,
+						/* test for JSON primitive types or given alternative */ T extends
+							| null
+							| boolean
+							| number
+							| string
+							| Controls["AllowExtensionOf"]
+							? /* primitive types or alternative => */ T
+							: /* test for exact alternative */ IfExactTypeInTuple<
+									T,
+									Controls["AllowExactly"],
+									T,
+									/* test for undefined possibility */ undefined extends T
+										? /* undefined | ... => */ SerializationErrorPerUndefinedArrayElement
+										: TBlessed
+								>
+					>;
 
 	/**
 	 * Filters a type `T` for types that become null through JSON serialization.
@@ -444,34 +448,35 @@ export namespace InternalUtilityTypes {
 		T,
 		Controls extends DeserializedFilterControls,
 		TBlessed,
-	> = /* Some initial filtering must be provided before a test for undefined, symbol, or function. */
-	/* These tests are expected to match those in JsonDeserializedImpl. */
-	/* test for 'any' */ boolean extends (T extends never ? true : false)
-		? /* 'any' => */ TBlessed
-		: /* test for 'unknown' */ unknown extends T
-			? /* 'unknown' => */ TBlessed
-			: /* test for JSON primitive types or general alternative */ T extends
-						| null
-						| boolean
-						| number
-						| string
-						| Controls["AllowExtensionOf"]
-				? /* primitive or replaced types => */ T
-				: /* test for exact alternative */ IfExactTypeInTuple<
-						T,
-						[...Controls["AllowExactly"], Controls["RecursionMarkerAllowed"]],
-						/* exactly replaced => */ T,
-						/* test for known types that become null */ T extends undefined | symbol
-							? /* => */ null
-							: // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-								T extends Function
-								? ExtractFunctionFromIntersection<T> extends {
-										classification: "exactly Function";
-									}
-									? null
-									: null | TBlessed
-								: TBlessed
-					>;
+	> =
+		/* Some initial filtering must be provided before a test for undefined, symbol, or function. */
+		/* These tests are expected to match those in JsonDeserializedImpl. */
+		/* test for 'any' */ boolean extends (T extends never ? true : false)
+			? /* 'any' => */ TBlessed
+			: /* test for 'unknown' */ unknown extends T
+				? /* 'unknown' => */ TBlessed
+				: /* test for JSON primitive types or general alternative */ T extends
+							| null
+							| boolean
+							| number
+							| string
+							| Controls["AllowExtensionOf"]
+					? /* primitive or replaced types => */ T
+					: /* test for exact alternative */ IfExactTypeInTuple<
+							T,
+							[...Controls["AllowExactly"], Controls["RecursionMarkerAllowed"]],
+							/* exactly replaced => */ T,
+							/* test for known types that become null */ T extends undefined | symbol
+								? /* => */ null
+								: // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+									T extends Function
+									? ExtractFunctionFromIntersection<T> extends {
+											classification: "exactly Function";
+										}
+										? null
+										: null | TBlessed
+									: TBlessed
+						>;
 
 	/**
 	 * Checks for a type that is simple class of number and string indexed types to numbers and strings.
@@ -515,11 +520,8 @@ export namespace InternalUtilityTypes {
 	 *
 	 * @system
 	 */
-	export type IfSameType<X, Y, IfSame = unknown, IfDifferent = never> = (<T>() => T extends X
-		? 1
-		: 2) extends <T>() => T extends Y ? 1 : 2
-		? IfSame
-		: IfDifferent;
+	export type IfSameType<X, Y, IfSame = unknown, IfDifferent = never> =
+		(<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? IfSame : IfDifferent;
 
 	/**
 	 * Test for type equality with tuple of other types.
@@ -551,7 +553,7 @@ export namespace InternalUtilityTypes {
 	 * @typeParam IfNoMatch - Type to return if no match is found.
 	 *
 	 * @remarks
-	 * In a recursive context, use {@link InternalUtilityTypes.IfExactTypeInTuple} to manage ancestry.
+	 * In a recursive context, use {@link InternalCoreInterfacesUtilityTypes.IfExactTypeInTuple} to manage ancestry.
 	 *
 	 * @privateRemarks
 	 * Perhaps it is a Typescript defect but a simple check that `T` is `never`
@@ -701,17 +703,15 @@ export namespace InternalUtilityTypes {
 	 *
 	 * @system
 	 */
-	export type FilterPreservingFunction<
-		Original extends object,
-		Filtered,
-	> = ExtractFunctionFromIntersection<Original> extends {
-		classification: infer TClassification;
-		function: infer TFunction;
-	}
-		? TClassification extends "exactly Function"
-			? TFunction
-			: TFunction & Filtered
-		: never;
+	export type FilterPreservingFunction<Original extends object, Filtered> =
+		ExtractFunctionFromIntersection<Original> extends {
+			classification: infer TClassification;
+			function: infer TFunction;
+		}
+			? TClassification extends "exactly Function"
+				? TFunction
+				: TFunction & Filtered
+			: never;
 
 	/**
 	 * Replaces any instance where a type T recurses into itself or a portion of
@@ -745,36 +745,37 @@ export namespace InternalUtilityTypes {
 		Controls extends FilterControls,
 		TAncestorTypes extends unknown[] = [],
 		TNextAncestor = T,
-	> = /* test for recursion */
-	IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
-		? /* recursion => use replacement */ TRecursionMarker
-		: /* force union separation hereafter */ T extends infer _
-			? /* test for recursion among union elements */
-				IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
-				? TRecursionMarker
-				: /* test for general allowance */ T extends Controls["AllowExtensionOf"]
-					? /* allowed extension type => */ T
-					: /* test for exact allowance */ IfExactTypeInTuple<
-								T,
-								Controls["AllowExactly"],
-								true,
-								"no match"
-							> extends true
-						? /* exact allowed type => */ T
-						: T extends object
-							? FilterPreservingFunction<
+	> =
+		/* test for recursion */
+		IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
+			? /* recursion => use replacement */ TRecursionMarker
+			: /* force union separation hereafter */ T extends infer _
+				? /* test for recursion among union elements */
+					IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
+					? TRecursionMarker
+					: /* test for general allowance */ T extends Controls["AllowExtensionOf"]
+						? /* allowed extension type => */ T
+						: /* test for exact allowance */ IfExactTypeInTuple<
 									T,
-									{
-										[K in keyof T]: ReplaceRecursionWithMarkerAndPreserveAllowances<
-											T[K],
-											TRecursionMarker,
-											Controls,
-											[TNextAncestor, ...TAncestorTypes]
-										>;
-									}
-								>
-							: /* non-object => T as is */ T
-			: never;
+									Controls["AllowExactly"],
+									true,
+									"no match"
+								> extends true
+							? /* exact allowed type => */ T
+							: T extends object
+								? FilterPreservingFunction<
+										T,
+										{
+											[K in keyof T]: ReplaceRecursionWithMarkerAndPreserveAllowances<
+												T[K],
+												TRecursionMarker,
+												Controls,
+												[TNextAncestor, ...TAncestorTypes]
+											>;
+										}
+									>
+								: /* non-object => T as is */ T
+				: never;
 
 	/**
 	 * Replaces any instances of "allowed" types and recursion within with `never`.
@@ -792,41 +793,42 @@ export namespace InternalUtilityTypes {
 		Controls extends FilterControls,
 		TAncestorTypes extends unknown[] = [],
 		TNextAncestor = T,
-	> = /* test for exact recursion first */ IfExactTypeInTuple<
-		T,
-		TAncestorTypes,
-		true,
-		"no match"
-	> extends true
-		? /* recursion => */ never
-		: /* test for general allowance (also forces union separation) */ T extends Controls["AllowExtensionOf"]
-			? /* allowed extension type => */ never
-			: /* test for exact allowance */ IfExactTypeInTuple<
-						T,
-						Controls["AllowExactly"],
-						true,
-						"no match"
-					> extends true
-				? /* exact allowed type => */ never
-				: /* test for recursion among union elements */ IfExactTypeInTuple<
+	> =
+		/* test for exact recursion first */ IfExactTypeInTuple<
+			T,
+			TAncestorTypes,
+			true,
+			"no match"
+		> extends true
+			? /* recursion => */ never
+			: /* test for general allowance (also forces union separation) */ T extends Controls["AllowExtensionOf"]
+				? /* allowed extension type => */ never
+				: /* test for exact allowance */ IfExactTypeInTuple<
 							T,
-							TAncestorTypes,
+							Controls["AllowExactly"],
 							true,
 							"no match"
 						> extends true
-					? /* recursion => */ never
-					: T extends object
-						? FilterPreservingFunction<
+					? /* exact allowed type => */ never
+					: /* test for recursion among union elements */ IfExactTypeInTuple<
 								T,
-								{
-									[K in keyof T]: ReplaceAllowancesAndRecursionWithNever<
-										T[K],
-										Controls,
-										[TNextAncestor, ...TAncestorTypes]
-									>;
-								}
-							>
-						: /* non-object => T as is */ T;
+								TAncestorTypes,
+								true,
+								"no match"
+							> extends true
+						? /* recursion => */ never
+						: T extends object
+							? FilterPreservingFunction<
+									T,
+									{
+										[K in keyof T]: ReplaceAllowancesAndRecursionWithNever<
+											T[K],
+											Controls,
+											[TNextAncestor, ...TAncestorTypes]
+										>;
+									}
+								>
+							: /* non-object => T as is */ T;
 
 	/**
 	 * Test for non-public properties (which can only exist on class instance types).
@@ -849,9 +851,8 @@ export namespace InternalUtilityTypes {
 		Controls extends FilterControls,
 		HasNonPublic = never,
 		OnlyPublics = unknown,
-	> = ReplaceAllowancesAndRecursionWithNever<T, Controls> extends T
-		? OnlyPublics
-		: HasNonPublic;
+	> =
+		ReplaceAllowancesAndRecursionWithNever<T, Controls> extends T ? OnlyPublics : HasNonPublic;
 
 	/**
 	 * Union of all types in a tuple.
@@ -878,74 +879,75 @@ export namespace InternalUtilityTypes {
 		},
 		TAncestorTypes extends unknown[] = [],
 		TNextAncestor = T,
-	> = /* Build Controls from Options filling in defaults for any missing properties */
-	{
-		AllowExactly: Options extends { AllowExactly: unknown[] } ? Options["AllowExactly"] : [];
-		AllowExtensionOf: Options extends { AllowExtensionOf: unknown }
-			? Options["AllowExtensionOf"]
-			: never;
-		// The Substitute type could be extracted to helper type, but is kept explicit here
-		// to make JsonTypeWith and OpaqueJsonSerializable show explicitly in results for
-		// users, rather than either the helper type name or a partially unrolled version.
-		DegenerateSubstitute:
-			| JsonTypeWith<
-					| (Options extends { AllowExactly: unknown[] }
-							? TupleToUnion<Options["AllowExactly"]>
-							: never)
-					| (Options extends { AllowExtensionOf: unknown }
-							? Options["AllowExtensionOf"]
-							: never)
-			  >
-			| OpaqueJsonSerializable<
-					unknown,
-					Options extends { AllowExactly: unknown[] } ? Options["AllowExactly"] : [],
-					Options extends { AllowExtensionOf: unknown } ? Options["AllowExtensionOf"] : never
-			  >;
-	} extends infer Controls
-		? /* Controls should always satisfy FilterControlsWithSubstitution, but Typescript wants a check */
-			Controls extends FilterControlsWithSubstitution
-			? /* test for 'any' */ boolean extends (T extends never ? true : false)
-				? /* 'any' => */ Controls["DegenerateSubstitute"]
-				: Options extends { IgnoreInaccessibleMembers: "ignore-inaccessible-members" }
-					? JsonSerializableFilter<T, Controls, TAncestorTypes, TNextAncestor>
-					: /* test for non-public properties (class instance type) */
-						IfNonPublicProperties<
-								T,
-								{
-									AllowExactly: Controls["AllowExactly"];
-									AllowExtensionOf:
-										| Controls["AllowExtensionOf"]
-										// Add in primitives that may be branded to ignore intersection classes
-										| boolean
-										| number
-										| string
-										// Add in OpaqueJson* types
-										| AnyOpaqueJsonType;
-								},
-								"found non-publics",
-								"only publics"
-							> extends "found non-publics"
-						? /* hidden props => test if it is array properties that are the problem */ T extends readonly (infer _)[]
-							? /* array => */ {
-									/* use homomorphic mapped type to preserve tuple type */
-									[K in keyof T]: JsonSerializableImpl<
-										T[K],
-										Controls,
-										[TNextAncestor, ...TAncestorTypes]
-									>;
-								}
-							: /* test for potentially branded primitive (intersection with a supported primitive) */
-								T extends boolean | number | string
-								? /* assume intersection is branding and allow as-is => */ T
-								: /* not array => error */ SerializationErrorPerNonPublicProperties
-						: /* no hidden properties => apply filtering => */ JsonSerializableFilter<
-								T,
-								Controls,
-								TAncestorTypes,
-								TNextAncestor
-							>
-			: never /* FilterControlsWithSubstitution assert else; should never be reached */
-		: never /* unreachable else for infer */;
+	> =
+		/* Build Controls from Options filling in defaults for any missing properties */
+		{
+			AllowExactly: Options extends { AllowExactly: unknown[] } ? Options["AllowExactly"] : [];
+			AllowExtensionOf: Options extends { AllowExtensionOf: unknown }
+				? Options["AllowExtensionOf"]
+				: never;
+			// The Substitute type could be extracted to helper type, but is kept explicit here
+			// to make JsonTypeWith and OpaqueJsonSerializable show explicitly in results for
+			// users, rather than either the helper type name or a partially unrolled version.
+			DegenerateSubstitute:
+				| JsonTypeWith<
+						| (Options extends { AllowExactly: unknown[] }
+								? TupleToUnion<Options["AllowExactly"]>
+								: never)
+						| (Options extends { AllowExtensionOf: unknown }
+								? Options["AllowExtensionOf"]
+								: never)
+				  >
+				| OpaqueJsonSerializable<
+						unknown,
+						Options extends { AllowExactly: unknown[] } ? Options["AllowExactly"] : [],
+						Options extends { AllowExtensionOf: unknown } ? Options["AllowExtensionOf"] : never
+				  >;
+		} extends infer Controls
+			? /* Controls should always satisfy FilterControlsWithSubstitution, but Typescript wants a check */
+				Controls extends FilterControlsWithSubstitution
+				? /* test for 'any' */ boolean extends (T extends never ? true : false)
+					? /* 'any' => */ Controls["DegenerateSubstitute"]
+					: Options extends { IgnoreInaccessibleMembers: "ignore-inaccessible-members" }
+						? JsonSerializableFilter<T, Controls, TAncestorTypes, TNextAncestor>
+						: /* test for non-public properties (class instance type) */
+							IfNonPublicProperties<
+									T,
+									{
+										AllowExactly: Controls["AllowExactly"];
+										AllowExtensionOf:
+											| Controls["AllowExtensionOf"]
+											// Add in primitives that may be branded to ignore intersection classes
+											| boolean
+											| number
+											| string
+											// Add in OpaqueJson* types
+											| AnyOpaqueJsonType;
+									},
+									"found non-publics",
+									"only publics"
+								> extends "found non-publics"
+							? /* hidden props => test if it is array properties that are the problem */ T extends readonly (infer _)[]
+								? /* array => */ {
+										/* use homomorphic mapped type to preserve tuple type */
+										[K in keyof T]: JsonSerializableImpl<
+											T[K],
+											Controls,
+											[TNextAncestor, ...TAncestorTypes]
+										>;
+									}
+								: /* test for potentially branded primitive (intersection with a supported primitive) */
+									T extends boolean | number | string
+									? /* assume intersection is branding and allow as-is => */ T
+									: /* not array => error */ SerializationErrorPerNonPublicProperties
+							: /* no hidden properties => apply filtering => */ JsonSerializableFilter<
+									T,
+									Controls,
+									TAncestorTypes,
+									TNextAncestor
+								>
+				: never /* FilterControlsWithSubstitution assert else; should never be reached */
+			: never /* unreachable else for infer */;
 
 	/**
 	 * Handle OpaqueJson* types for {@link JsonSerializable}.
@@ -968,28 +970,41 @@ export namespace InternalUtilityTypes {
 	export type JsonSerializableOpaqueAllowances<
 		T extends AnyOpaqueJsonType,
 		Controls extends FilterControlsWithSubstitution,
-	> = /* eslint-disable @typescript-eslint/no-explicit-any -- must use `any` for invariant constraint override */
-	/* infer underlying data type */ T extends
-		| OpaqueJsonSerializable<infer TData, any, unknown>
-		| OpaqueJsonDeserialized<infer TData, any, unknown>
-		? T extends OpaqueJsonSerializable<TData, any, unknown> &
-				OpaqueJsonDeserialized<TData, any, unknown>
-			? OpaqueJsonSerializable<TData, Controls["AllowExactly"], Controls["AllowExtensionOf"]> &
-					OpaqueJsonDeserialized<TData, Controls["AllowExactly"], Controls["AllowExtensionOf"]>
-			: T extends OpaqueJsonSerializable<TData, any, unknown>
-				? OpaqueJsonSerializable<TData, Controls["AllowExactly"], Controls["AllowExtensionOf"]>
-				: T extends OpaqueJsonDeserialized<TData, any, unknown>
-					? OpaqueJsonDeserialized<
+	> =
+		/* eslint-disable @typescript-eslint/no-explicit-any -- must use `any` for invariant constraint override */
+		/* infer underlying data type */ T extends
+			| OpaqueJsonSerializable<infer TData, any, unknown>
+			| OpaqueJsonDeserialized<infer TData, any, unknown>
+			? T extends OpaqueJsonSerializable<TData, any, unknown> &
+					OpaqueJsonDeserialized<TData, any, unknown>
+				? OpaqueJsonSerializable<
+						TData,
+						Controls["AllowExactly"],
+						Controls["AllowExtensionOf"]
+					> &
+						OpaqueJsonDeserialized<
 							TData,
 							Controls["AllowExactly"],
 							Controls["AllowExtensionOf"]
 						>
-					: "internal error: failed to determine OpaqueJson* type"
-		: never;
+				: T extends OpaqueJsonSerializable<TData, any, unknown>
+					? OpaqueJsonSerializable<
+							TData,
+							Controls["AllowExactly"],
+							Controls["AllowExtensionOf"]
+						>
+					: T extends OpaqueJsonDeserialized<TData, any, unknown>
+						? OpaqueJsonDeserialized<
+								TData,
+								Controls["AllowExactly"],
+								Controls["AllowExtensionOf"]
+							>
+						: "internal error: failed to determine OpaqueJson* type"
+			: never;
 	/* eslint-enable @typescript-eslint/no-explicit-any */
 
 	/**
-	 * Helper for {@link JsonSerializableFilter} to determine if a property may
+	 * Helper for {@link InternalCoreInterfacesUtilityTypes.JsonSerializableFilter} to determine if a property may
 	 * be `undefined` and selects from options for result.
 	 * Since `unknown` is a superset of `undefined`, it is given a special case.
 	 * Additionally since index signatures are inherently optional, `unknown` typed
@@ -1153,79 +1168,90 @@ export namespace InternalUtilityTypes {
 		T,
 		Options extends Partial<FilterControls>,
 		TypeUnderRecursion extends boolean = false,
-	> = /* Build Controls from Options filling in defaults for any missing properties */
-	{
-		AllowExactly: Options extends { AllowExactly: unknown[] } ? Options["AllowExactly"] : [];
-		AllowExtensionOf: Options extends { AllowExtensionOf: unknown }
-			? Options["AllowExtensionOf"]
-			: never;
-		// The Substitute types could be extracted to helper type, but are kept explicit here
-		// to make JsonTypeWith/NonNullJsonObjectWith show explicitly in results for users, rather
-		// than either the helper type name or a partially unrolled version.
-		DegenerateSubstitute: JsonTypeWith<
-			| (Options extends { AllowExactly: unknown[] }
-					? TupleToUnion<Options["AllowExactly"]>
-					: never)
-			| (Options extends { AllowExtensionOf: unknown } ? Options["AllowExtensionOf"] : never)
-		>;
-		DegenerateNonNullObjectSubstitute: NonNullJsonObjectWith<
-			| (Options extends { AllowExactly: unknown[] }
-					? TupleToUnion<Options["AllowExactly"]>
-					: never)
-			| (Options extends { AllowExtensionOf: unknown } ? Options["AllowExtensionOf"] : never)
-		>;
-		RecursionMarkerAllowed: never;
-	} extends infer Controls
-		? /* Controls should always satisfy DeserializedFilterControls, but Typescript wants a check */
-			Controls extends DeserializedFilterControls
-			? /* test for 'any' */ boolean extends (T extends never ? true : false)
-				? /* 'any' => */ Controls["DegenerateSubstitute"]
-				: /* infer non-recursive version of T */ ReplaceRecursionWithMarkerAndPreserveAllowances<
-							T,
-							RecursionMarker,
-							{
-								AllowExactly: Controls["AllowExactly"];
-								AllowExtensionOf:
-									| Controls["AllowExtensionOf"]
-									// Also preserve OpaqueJson* types
-									| AnyOpaqueJsonType;
-							}
-						> extends infer TNoRecursionAndOnlyPublics
-					? /* test for no change from filtered type */ IsSameType<
-							TNoRecursionAndOnlyPublics,
-							JsonDeserializedFilter<
-								TNoRecursionAndOnlyPublics,
-								{
-									AllowExactly: Controls["AllowExactly"];
-									AllowExtensionOf: Controls["AllowExtensionOf"];
-									DegenerateSubstitute: Controls["DegenerateSubstitute"];
-									DegenerateNonNullObjectSubstitute: Controls["DegenerateNonNullObjectSubstitute"];
-									RecursionMarkerAllowed: RecursionMarker;
-								}
-							>
-						> extends true
-						? /* same (no filtering needed) => test for non-public
-						     properties (class instance type) */
-							IfNonPublicProperties<
+	> =
+		/* Build Controls from Options filling in defaults for any missing properties */
+		{
+			AllowExactly: Options extends { AllowExactly: unknown[] } ? Options["AllowExactly"] : [];
+			AllowExtensionOf: Options extends { AllowExtensionOf: unknown }
+				? Options["AllowExtensionOf"]
+				: never;
+			// The Substitute types could be extracted to helper type, but are kept explicit here
+			// to make JsonTypeWith/NonNullJsonObjectWith show explicitly in results for users, rather
+			// than either the helper type name or a partially unrolled version.
+			DegenerateSubstitute: JsonTypeWith<
+				| (Options extends { AllowExactly: unknown[] }
+						? TupleToUnion<Options["AllowExactly"]>
+						: never)
+				| (Options extends { AllowExtensionOf: unknown } ? Options["AllowExtensionOf"] : never)
+			>;
+			DegenerateNonNullObjectSubstitute: NonNullJsonObjectWith<
+				| (Options extends { AllowExactly: unknown[] }
+						? TupleToUnion<Options["AllowExactly"]>
+						: never)
+				| (Options extends { AllowExtensionOf: unknown } ? Options["AllowExtensionOf"] : never)
+			>;
+			RecursionMarkerAllowed: never;
+		} extends infer Controls
+			? /* Controls should always satisfy DeserializedFilterControls, but Typescript wants a check */
+				Controls extends DeserializedFilterControls
+				? /* test for 'any' */ boolean extends (T extends never ? true : false)
+					? /* 'any' => */ Controls["DegenerateSubstitute"]
+					: /* infer non-recursive version of T */ ReplaceRecursionWithMarkerAndPreserveAllowances<
 								T,
-								// Note: no extra allowance is made here for possible branded
-								// primitives as JsonDeserializedFilter will allow them as
-								// extensions of the primitives. Should there be a need to
-								// explicitly allow them here, see JsonSerializableImpl's use.
+								RecursionMarker,
 								{
 									AllowExactly: Controls["AllowExactly"];
 									AllowExtensionOf:
 										| Controls["AllowExtensionOf"]
-										// Add in OpaqueJson* types
+										// Also preserve OpaqueJson* types
 										| AnyOpaqueJsonType;
-								},
-								"found non-publics",
-								"only publics"
-							> extends "found non-publics"
-							? /* hidden props => apply filtering to avoid retaining
+								}
+							> extends infer TNoRecursionAndOnlyPublics
+						? /* test for no change from filtered type */ IsSameType<
+								TNoRecursionAndOnlyPublics,
+								JsonDeserializedFilter<
+									TNoRecursionAndOnlyPublics,
+									{
+										AllowExactly: Controls["AllowExactly"];
+										AllowExtensionOf: Controls["AllowExtensionOf"];
+										DegenerateSubstitute: Controls["DegenerateSubstitute"];
+										DegenerateNonNullObjectSubstitute: Controls["DegenerateNonNullObjectSubstitute"];
+										RecursionMarkerAllowed: RecursionMarker;
+									}
+								>
+							> extends true
+							? /* same (no filtering needed) => test for non-public
+						     properties (class instance type) */
+								IfNonPublicProperties<
+									T,
+									// Note: no extra allowance is made here for possible branded
+									// primitives as JsonDeserializedFilter will allow them as
+									// extensions of the primitives. Should there be a need to
+									// explicitly allow them here, see JsonSerializableImpl's use.
+									{
+										AllowExactly: Controls["AllowExactly"];
+										AllowExtensionOf:
+											| Controls["AllowExtensionOf"]
+											// Add in OpaqueJson* types
+											| AnyOpaqueJsonType;
+									},
+									"found non-publics",
+									"only publics"
+								> extends "found non-publics"
+								? /* hidden props => apply filtering to avoid retaining
 							     exact class except for any classes in allowances =>
 								 test for known recursion */
-								TypeUnderRecursion extends false
+									TypeUnderRecursion extends false
+									? /* no known recursion => */ JsonDeserializedFilter<T, Controls>
+									: /* known recursion => use OpaqueJsonDeserialized for later processing */
+										OpaqueJsonDeserialized<
+											T,
+											Controls["AllowExactly"],
+											Controls["AllowExtensionOf"]
+										>
+								: /* no hidden properties => deserialized T is just T */
+									T
+							: /* filtering is needed => test for known recursion */ TypeUnderRecursion extends false
 								? /* no known recursion => */ JsonDeserializedFilter<T, Controls>
 								: /* known recursion => use OpaqueJsonDeserialized for later processing */
 									OpaqueJsonDeserialized<
@@ -1233,22 +1259,12 @@ export namespace InternalUtilityTypes {
 										Controls["AllowExactly"],
 										Controls["AllowExtensionOf"]
 									>
-							: /* no hidden properties => deserialized T is just T */
-								T
-						: /* filtering is needed => test for known recursion */ TypeUnderRecursion extends false
-							? /* no known recursion => */ JsonDeserializedFilter<T, Controls>
-							: /* known recursion => use OpaqueJsonDeserialized for later processing */
-								OpaqueJsonDeserialized<
-									T,
-									Controls["AllowExactly"],
-									Controls["AllowExtensionOf"]
-								>
-					: /* unreachable else for infer */ never
-			: never /* DeserializedFilterControls assert else; should never be reached */
-		: never /* unreachable else for infer */;
+						: /* unreachable else for infer */ never
+				: never /* DeserializedFilterControls assert else; should never be reached */
+			: never /* unreachable else for infer */;
 
 	/**
-	 * Recurses `T` applying {@link InternalUtilityTypes.JsonDeserializedFilter} up until
+	 * Recurses `T` applying {@link InternalCoreInterfacesUtilityTypes.JsonDeserializedFilter} up until
 	 * `T` is found to be a match of an ancestor type. At that point `T` is wrapped in
 	 * {@link OpaqueJsonDeserialized} to avoid further immediate processing, if
 	 * modification is needed. Caller will need to unwrap the type to continue processing.
@@ -1265,27 +1281,28 @@ export namespace InternalUtilityTypes {
 		T,
 		Controls extends DeserializedFilterControls,
 		TAncestorTypes extends object[],
-	> = IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
-		? /* recursion found => reprocess that recursive type directly to avoid
+	> =
+		IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
+			? /* recursion found => reprocess that recursive type directly to avoid
 		     any collateral damage from ancestor type that required modification.
 			 Further recursion will not happen during processing. Either:
 			  - the type requires modification and the `TypeUnderRecursion=true`
 			    arg will result in `OpaqueJsonDeserialized<T>` wrapper OR
 			  - no change is needed from this point and `T` will result. */
-			JsonDeserializedImpl<T, Controls, true>
-		: T extends object
-			? IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
-				? JsonDeserializedImpl<T, Controls, true>
-				: /* no recursion yet detected => */ JsonDeserializedFilter<
+				JsonDeserializedImpl<T, Controls, true>
+			: T extends object
+				? IfExactTypeInTuple<T, TAncestorTypes, true, "no match"> extends true
+					? JsonDeserializedImpl<T, Controls, true>
+					: /* no recursion yet detected => */ JsonDeserializedFilter<
+							T,
+							Controls,
+							[...TAncestorTypes, T]
+						>
+				: /* not an object (no recursion) => */ JsonDeserializedFilter<
 						T,
 						Controls,
-						[...TAncestorTypes, T]
-					>
-			: /* not an object (no recursion) => */ JsonDeserializedFilter<
-					T,
-					Controls,
-					TAncestorTypes
-				>;
+						TAncestorTypes
+					>;
 
 	/**
 	 * Handle OpaqueJson* types for {@link JsonDeserialized}.
@@ -1308,12 +1325,13 @@ export namespace InternalUtilityTypes {
 	export type JsonDeserializedOpaqueConversion<
 		T extends AnyOpaqueJsonType,
 		Controls extends FilterControls,
-	> = /* eslint-disable @typescript-eslint/no-explicit-any -- must use `any` for invariant constraint override */
-	T extends
-		| OpaqueJsonSerializable<infer TData, any, unknown>
-		| OpaqueJsonDeserialized<infer TData, any, unknown>
-		? OpaqueJsonDeserialized<TData, Controls["AllowExactly"], Controls["AllowExtensionOf"]>
-		: "internal error: failed to determine OpaqueJson* type";
+	> =
+		/* eslint-disable @typescript-eslint/no-explicit-any -- must use `any` for invariant constraint override */
+		T extends
+			| OpaqueJsonSerializable<infer TData, any, unknown>
+			| OpaqueJsonDeserialized<infer TData, any, unknown>
+			? OpaqueJsonDeserialized<TData, Controls["AllowExactly"], Controls["AllowExtensionOf"]>
+			: "internal error: failed to determine OpaqueJson* type";
 	/* eslint-enable @typescript-eslint/no-explicit-any */
 
 	/**
@@ -1418,14 +1436,15 @@ export namespace InternalUtilityTypes {
 		DeepenedGenerics extends ReadonlySupportedGenerics,
 		NoDepthOrRecurseLimit extends "Shallow" | DeepReadonlyRecursionLimit,
 		Else,
-	> = T extends ReadonlyMap<infer K, infer V>
-		? Map<K, V> extends DeepenedGenerics
-			? ReadonlyMap<
-					ReadonlyImpl<K, DeepenedGenerics, NoDepthOrRecurseLimit>,
-					ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>
-				>
-			: ReadonlyMap<K, V>
-		: Else;
+	> =
+		T extends ReadonlyMap<infer K, infer V>
+			? Map<K, V> extends DeepenedGenerics
+				? ReadonlyMap<
+						ReadonlyImpl<K, DeepenedGenerics, NoDepthOrRecurseLimit>,
+						ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>
+					>
+				: ReadonlyMap<K, V>
+			: Else;
 
 	/**
 	 * If `T` is a `Set<TSet>` or `ReadonlySet<TSet>`, returns `ReadonlySet` and,
@@ -1439,11 +1458,12 @@ export namespace InternalUtilityTypes {
 		DeepenedGenerics extends ReadonlySupportedGenerics,
 		NoDepthOrRecurseLimit extends "Shallow" | DeepReadonlyRecursionLimit,
 		Else,
-	> = T extends ReadonlySet<infer V>
-		? Set<V> extends DeepenedGenerics
-			? ReadonlySet<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>
-			: ReadonlySet<V>
-		: Else;
+	> =
+		T extends ReadonlySet<infer V>
+			? Set<V> extends DeepenedGenerics
+				? ReadonlySet<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>
+				: ReadonlySet<V>
+			: Else;
 
 	/**
 	 * If `T` is a `IFluidHandle<THandle>` and if `T` extends `DeepenedGenerics`,
@@ -1457,11 +1477,12 @@ export namespace InternalUtilityTypes {
 		DeepenedGenerics extends ReadonlySupportedGenerics,
 		NoDepthOrRecurseLimit extends "Shallow" | DeepReadonlyRecursionLimit,
 		Else,
-	> = T extends Readonly<IFluidHandle<infer V>>
-		? IFluidHandle<V> extends DeepenedGenerics
-			? Readonly<IFluidHandle<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>>
-			: Readonly<T>
-		: Else;
+	> =
+		T extends Readonly<IFluidHandle<infer V>>
+			? IFluidHandle<V> extends DeepenedGenerics
+				? Readonly<IFluidHandle<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>>
+				: Readonly<T>
+			: Else;
 
 	/**
 	 * If `T` is a `Promise<TPromise>` and if `T` extends `DeepenedGenerics`,
@@ -1475,11 +1496,12 @@ export namespace InternalUtilityTypes {
 		DeepenedGenerics extends ReadonlySupportedGenerics,
 		NoDepthOrRecurseLimit extends "Shallow" | DeepReadonlyRecursionLimit,
 		Else,
-	> = T extends Promise<infer V>
-		? Promise<V> extends DeepenedGenerics
-			? Promise<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>
-			: T
-		: Else;
+	> =
+		T extends Promise<infer V>
+			? Promise<V> extends DeepenedGenerics
+				? Promise<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>
+				: T
+			: Else;
 
 	/**
 	 * If `T` is a `WeakMap<K,V>`, returns immutable `WeakMap` and,
@@ -1493,17 +1515,18 @@ export namespace InternalUtilityTypes {
 		DeepenedGenerics extends ReadonlySupportedGenerics,
 		NoDepthOrRecurseLimit extends "Shallow" | DeepReadonlyRecursionLimit,
 		Else,
-	> = T extends Omit<WeakMap<infer K, infer V>, "delete" | "set">
-		? WeakMap<K, V> extends DeepenedGenerics
-			? Omit<
-					WeakMap<
-						ReadonlyImpl<K, DeepenedGenerics, NoDepthOrRecurseLimit>,
-						ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>
-					>,
-					"delete" | "set"
-				>
-			: Omit<WeakMap<K, V>, "delete" | "set">
-		: Else;
+	> =
+		T extends Omit<WeakMap<infer K, infer V>, "delete" | "set">
+			? WeakMap<K, V> extends DeepenedGenerics
+				? Omit<
+						WeakMap<
+							ReadonlyImpl<K, DeepenedGenerics, NoDepthOrRecurseLimit>,
+							ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>
+						>,
+						"delete" | "set"
+					>
+				: Omit<WeakMap<K, V>, "delete" | "set">
+			: Else;
 
 	/**
 	 * If `T` is a `WeakSet<TSet>`, returns immutable `WeakSet` and,
@@ -1517,14 +1540,15 @@ export namespace InternalUtilityTypes {
 		DeepenedGenerics extends ReadonlySupportedGenerics,
 		NoDepthOrRecurseLimit extends "Shallow" | DeepReadonlyRecursionLimit,
 		Else,
-	> = T extends Omit<WeakSet<infer V>, "add" | "delete">
-		? WeakSet<V> extends DeepenedGenerics
-			? Omit<
-					WeakSet<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>,
-					"add" | "delete"
-				>
-			: Omit<WeakSet<V>, "add" | "delete">
-		: Else;
+	> =
+		T extends Omit<WeakSet<infer V>, "add" | "delete">
+			? WeakSet<V> extends DeepenedGenerics
+				? Omit<
+						WeakSet<ReadonlyImpl<V, DeepenedGenerics, NoDepthOrRecurseLimit>>,
+						"add" | "delete"
+					>
+				: Omit<WeakSet<V>, "add" | "delete">
+			: Else;
 
 	/**
 	 * If `T` is a {@link ReadonlySupportedGenerics}, `T` is returned as
@@ -1577,19 +1601,17 @@ export namespace InternalUtilityTypes {
 	 *
 	 * @system
 	 */
-	export type PreserveErasedTypeOrBrandedPrimitive<
-		T extends object,
-		Else,
-	> = /* Test for erased type */ T extends ErasedType<infer _>
-		? /* erased type => keep as-is */ T
-		: /* Test for branded primitive */ T extends infer Brand &
-					(boolean | number | string | symbol | bigint)
-			? // Should just return T here, but TypeScript appears to produce `never` when doing so.
-				// Workaround by inferring the Primitive type and returning intersection with B.
-				T extends Brand & infer Primitive
-				? /* [potentially] branded type => "as-is" */ Primitive & Brand
-				: /* Should never be reached */ T
-			: Else;
+	export type PreserveErasedTypeOrBrandedPrimitive<T extends object, Else> =
+		/* Test for erased type */ T extends ErasedType<infer _>
+			? /* erased type => keep as-is */ T
+			: /* Test for branded primitive */ T extends infer Brand &
+						(boolean | number | string | symbol | bigint)
+				? // Should just return T here, but TypeScript appears to produce `never` when doing so.
+					// Workaround by inferring the Primitive type and returning intersection with B.
+					T extends Brand & infer Primitive
+					? /* [potentially] branded type => "as-is" */ Primitive & Brand
+					: /* Should never be reached */ T
+				: Else;
 
 	/**
 	 * De-multiplexing implementation of {@link DeepReadonly} and {@link ShallowReadonly}
@@ -1724,43 +1746,44 @@ export namespace InternalUtilityTypes {
 		T,
 		DeepenedGenerics extends ReadonlySupportedGenerics,
 		NoDepthOrRecurseLimit extends RecursionLimit,
-	> = /* infer non-recursive version of T */ ReplaceRecursionWithMarkerAndPreserveAllowances<
-		T,
-		RecursionMarker,
-		{ AllowExactly: []; AllowExtensionOf: never }
-	> extends infer TNoRecursionAndOnlyPublics
-		? /* test for no change from altered type (excluding non-publics) */ IsSameType<
-				TNoRecursionAndOnlyPublics,
-				DeepReadonlyWorker<TNoRecursionAndOnlyPublics, DeepenedGenerics, 0>
-			> extends true
-			? /* same (no filtering needed) => test for non-public properties (class instance type) */
-				IfNonPublicProperties<
-					T,
-					// Note: no extra allowance is made here for possible branded
-					// primitives as DeepReadonlyWorker will allow them as
-					// extensions of the primitives. Should there need a need to
-					// explicit allow them here, see JsonSerializableImpl's use.
-					{ AllowExactly: []; AllowExtensionOf: never },
-					"found non-publics",
-					"only publics"
-				> extends "found non-publics"
-				? /* hidden props => apply filtering => */
-					DeepReadonlyWorker<
+	> =
+		/* infer non-recursive version of T */ ReplaceRecursionWithMarkerAndPreserveAllowances<
+			T,
+			RecursionMarker,
+			{ AllowExactly: []; AllowExtensionOf: never }
+		> extends infer TNoRecursionAndOnlyPublics
+			? /* test for no change from altered type (excluding non-publics) */ IsSameType<
+					TNoRecursionAndOnlyPublics,
+					DeepReadonlyWorker<TNoRecursionAndOnlyPublics, DeepenedGenerics, 0>
+				> extends true
+				? /* same (no filtering needed) => test for non-public properties (class instance type) */
+					IfNonPublicProperties<
+						T,
+						// Note: no extra allowance is made here for possible branded
+						// primitives as DeepReadonlyWorker will allow them as
+						// extensions of the primitives. Should there need a need to
+						// explicit allow them here, see JsonSerializableImpl's use.
+						{ AllowExactly: []; AllowExtensionOf: never },
+						"found non-publics",
+						"only publics"
+					> extends "found non-publics"
+					? /* hidden props => apply filtering => */
+						DeepReadonlyWorker<
+							T,
+							DeepenedGenerics,
+							Extract<NoDepthOrRecurseLimit, RecursionLimit>
+						>
+					: /* no hidden properties => readonly T is just T */
+						T
+				: /* filtering is needed => */ DeepReadonlyWorker<
 						T,
 						DeepenedGenerics,
 						Extract<NoDepthOrRecurseLimit, RecursionLimit>
 					>
-				: /* no hidden properties => readonly T is just T */
-					T
-			: /* filtering is needed => */ DeepReadonlyWorker<
-					T,
-					DeepenedGenerics,
-					Extract<NoDepthOrRecurseLimit, RecursionLimit>
-				>
-		: /* unreachable else for infer */ never;
+			: /* unreachable else for infer */ never;
 
 	/**
-	 * Recurses `T` applying {@link InternalUtilityTypes.DeepReadonlyWorker} up to `RecurseLimit` times.
+	 * Recurses `T` applying {@link InternalCoreInterfacesUtilityTypes.DeepReadonlyWorker} up to `RecurseLimit` times.
 	 *
 	 * @system
 	 */
@@ -1783,7 +1806,7 @@ export namespace InternalUtilityTypes {
 		: DeepReadonlyWorker<T, DeepenedGenerics, RecurseLimit, TAncestorTypes | T>;
 
 	/**
-	 * Core implementation of {@link InternalUtilityTypes.DeepReadonlyLimitingRecursion}.
+	 * Core implementation of {@link InternalCoreInterfacesUtilityTypes.DeepReadonlyLimitingRecursion}.
 	 *
 	 * @system
 	 */