@haneullabs/haneul 0.1.0 → 2.5.0

package/src/transactions/plugins/NamedPackagesPlugin.ts

@@ -1,83 +1,16 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { ClientCache } from '../../experimental/cache.js';
-import { MvrClient } from '../../experimental/mvr.js';
+import { findNamesInTransaction, replaceNames } from '../../client/mvr.js';
 import type { BuildTransactionOptions } from '../resolve.js';
 import type { TransactionDataBuilder } from '../TransactionData.js';
-import { findNamesInTransaction, replaceNames } from '../../experimental/mvr.js';
-import type { NamedPackagesOverrides } from '../../experimental/mvr.js';
-
-export type NamedPackagesPluginOptions = {
-	/**
-	 * The URL of the MVR API to use for resolving names.
-	 */
-	url: string;
-	/**
-	 * The number of names to resolve in each batch request.
-	 * Needs to be calculated based on the GraphQL query limits.
-	 */
-	pageSize?: number;
-	/**
-	 * Local overrides for the resolution plugin. Pass this to pre-populate
-	 * the cache with known packages / types (especially useful for local or CI testing).
-	 *
-	 * The type cache expects ONLY first-level types to ensure the cache is more composable.
-	 *
-	 * 	Expected format example:
-	 *  {
-	 * 		packages: {
-	 * 			'@framework/std': '0x1234',
-	 * 		},
-	 * 		types: {
-	 * 			'@framework/std::string::String': '0x1234::string::String',
-	 * 		},
-	 * 	}
-	 *
-	 */
-	overrides?: NamedPackagesOverrides;
-};
-
-// The original versions of the mvr plugin cached lookups by mutating overrides.
-// We don't want to mutate the options, but we can link our cache to the provided overrides object
-// This preserves the caching across transactions while removing the mutation side effects
-const cacheMap = new WeakMap<object, ClientCache>();
 
 /**
- * @experimental This plugin is in experimental phase and there might be breaking changes in the future
- *
- * Adds named resolution so that you can use .move names in your transactions.
- * e.g. `@org/app::type::Type` will be resolved to `0x1234::type::Type`.
- * This plugin will resolve all names & types in the transaction block.
- *
- * To install this plugin globally in your app, use:
- * ```
- * Transaction.registerGlobalSerializationPlugin("namedPackagesPlugin", namedPackagesPlugin({ suiGraphQLClient }));
- * ```
- *
- * You can also define `overrides` to pre-populate name resolutions locally (removes the GraphQL request).
+ * Internal plugin that automatically resolves MVR names in transactions.
+ * This plugin is automatically added to all transactions and uses the client's
+ * MVR resolver to convert .move names to on-chain addresses.
  */
-export const namedPackagesPlugin = (options?: NamedPackagesPluginOptions) => {
-	let mvrClient: MvrClient | undefined;
-
-	if (options) {
-		const overrides = options.overrides ?? {
-			packages: {},
-			types: {},
-		};
-
-		if (!cacheMap.has(overrides)) {
-			cacheMap.set(overrides, new ClientCache());
-		}
-
-		mvrClient = new MvrClient({
-			cache: cacheMap.get(overrides)!,
-			url: options.url,
-			pageSize: options.pageSize,
-			overrides: overrides,
-		});
-	}
-
+export function namedPackagesPlugin() {
 	return async (
 		transactionData: TransactionDataBuilder,
 		buildOptions: BuildTransactionOptions,
@@ -89,7 +22,13 @@ export const namedPackagesPlugin = (options?: NamedPackagesPluginOptions) => {
 			return next();
 		}
 
-		const resolved = await (mvrClient || getClient(buildOptions).core.mvr).resolve({
+		if (!buildOptions.client) {
+			throw new Error(
+				`Transaction contains MVR names but no client was provided to resolve them. Please pass a client to Transaction#build()`,
+			);
+		}
+
+		const resolved = await buildOptions.client.core.mvr.resolve({
 			types: names.types,
 			packages: names.packages,
 		});
@@ -98,14 +37,4 @@ export const namedPackagesPlugin = (options?: NamedPackagesPluginOptions) => {
 
 		await next();
 	};
-};
-
-export function getClient(options: BuildTransactionOptions) {
-	if (!options.client) {
-		throw new Error(
-			`No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`,
-		);
-	}
-
-	return options.client;
 }

package/src/transactions/resolve.ts

@@ -3,13 +3,12 @@
 
 import type { Argument } from './data/internal.js';
 
-import type { ClientWithCoreApi } from '../experimental/index.js';
+import type { ClientWithCoreApi } from '../client/index.js';
 import type { TransactionDataBuilder } from './TransactionData.js';
 import type { BcsType } from '@haneullabs/bcs';
 import { Inputs } from './Inputs.js';
 import { bcs } from '../bcs/index.js';
-import { jsonRpcClientResolveTransactionPlugin } from '../jsonRpc/json-rpc-resolver.js';
-import type { HaneulJsonRpcClient } from '../jsonRpc/client.js';
+import { coreClientResolveTransactionPlugin } from '../client/core-resolver.js';
 
 export interface BuildTransactionOptions {
 	client?: ClientWithCoreApi;
@@ -39,7 +38,11 @@ export function needsTransactionResolution(
 	}
 
 	if (!options.onlyTransactionKind) {
-		if (!data.gasConfig.price || !data.gasConfig.budget || !data.gasConfig.payment) {
+		if (!data.gasData.price || !data.gasData.budget || !data.gasData.payment) {
+			return true;
+		}
+
+		if (data.gasData.payment.length === 0 && !data.expiration) {
 			return true;
 		}
 	}
@@ -59,9 +62,7 @@ export async function resolveTransactionPlugin(
 	}
 
 	const client = getClient(options);
-	const plugin =
-		client.core?.resolveTransactionPlugin() ??
-		jsonRpcClientResolveTransactionPlugin(client as HaneulJsonRpcClient);
+	const plugin = client.core?.resolveTransactionPlugin() ?? coreClientResolveTransactionPlugin;
 
 	return plugin(transactionData, options, async () => {
 		await validate(transactionData);
@@ -71,9 +72,9 @@ export async function resolveTransactionPlugin(
 
 function validate(transactionData: TransactionDataBuilder) {
 	transactionData.inputs.forEach((input, index) => {
-		if (input.$kind !== 'Object' && input.$kind !== 'Pure') {
+		if (input.$kind !== 'Object' && input.$kind !== 'Pure' && input.$kind !== 'FundsWithdrawal') {
 			throw new Error(
-				`Input at index ${index} has not been resolved.  Expected a Pure or Object input, but found ${JSON.stringify(
+				`Input at index ${index} has not been resolved.  Expected a Pure, Object, or FundsWithdrawal input, but found ${JSON.stringify(
 					input,
 				)}`,
 			);
@@ -84,7 +85,7 @@ function validate(transactionData: TransactionDataBuilder) {
 export function getClient(options: BuildTransactionOptions) {
 	if (!options.client) {
 		throw new Error(
-			`No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`,
+			`No haneul client passed to Transaction#build, but transaction data was not sufficient to build offline.`,
 		);
 	}
 

package/src/transactions/serializer.ts

@@ -4,209 +4,190 @@
 import type { BcsType } from '@haneullabs/bcs';
 
 import { bcs } from '../bcs/index.js';
-import type { HaneulMoveNormalizedType } from '../client/index.js';
+import type { HaneulMoveNormalizedType } from '../jsonRpc/index.js';
 import { MOVE_STDLIB_ADDRESS, HANEUL_FRAMEWORK_ADDRESS } from '../utils/index.js';
 import { normalizeHaneulAddress } from '../utils/haneul-types.js';
-import type { OpenMoveTypeSignature, OpenMoveTypeSignatureBody } from './data/internal.js';
-
-const OBJECT_MODULE_NAME = 'object';
-const ID_STRUCT_NAME = 'ID';
-
-const STD_ASCII_MODULE_NAME = 'ascii';
-const STD_ASCII_STRUCT_NAME = 'String';
-
-const STD_UTF8_MODULE_NAME = 'string';
-const STD_UTF8_STRUCT_NAME = 'String';
+import type { HaneulClientTypes } from '../client/types.js';
+
+/**
+ * Parses a type name like "0x2::tx_context::TxContext" into package, module, and name parts.
+ */
+function parseTypeName(typeName: string): { package: string; module: string; name: string } {
+	const parts = typeName.split('::');
+	if (parts.length !== 3) {
+		throw new Error(`Invalid type name format: ${typeName}`);
+	}
+	return { package: parts[0], module: parts[1], name: parts[2] };
+}
 
-const STD_OPTION_MODULE_NAME = 'option';
-const STD_OPTION_STRUCT_NAME = 'Option';
+export function isTxContext(param: HaneulClientTypes.OpenSignature): boolean {
+	if (param.body.$kind !== 'datatype') {
+		return false;
+	}
 
-export function isTxContext(param: OpenMoveTypeSignature): boolean {
-	const struct =
-		typeof param.body === 'object' && 'datatype' in param.body ? param.body.datatype : null;
+	const { package: pkg, module, name } = parseTypeName(param.body.datatype.typeName);
 
 	return (
-		!!struct &&
-		normalizeHaneulAddress(struct.package) === normalizeHaneulAddress('0x2') &&
-		struct.module === 'tx_context' &&
-		struct.type === 'TxContext'
+		normalizeHaneulAddress(pkg) === HANEUL_FRAMEWORK_ADDRESS &&
+		module === 'tx_context' &&
+		name === 'TxContext'
 	);
 }
 
-export function getPureBcsSchema(typeSignature: OpenMoveTypeSignatureBody): BcsType<any> | null {
-	if (typeof typeSignature === 'string') {
-		switch (typeSignature) {
-			case 'address':
-				return bcs.Address;
-			case 'bool':
-				return bcs.Bool;
-			case 'u8':
-				return bcs.U8;
-			case 'u16':
-				return bcs.U16;
-			case 'u32':
-				return bcs.U32;
-			case 'u64':
-				return bcs.U64;
-			case 'u128':
-				return bcs.U128;
-			case 'u256':
-				return bcs.U256;
-			default:
-				throw new Error(`Unknown type signature ${typeSignature}`);
-		}
-	}
-
-	if ('vector' in typeSignature) {
-		if (typeSignature.vector === 'u8') {
-			return bcs.byteVector().transform({
-				input: (val: string | Uint8Array) =>
-					typeof val === 'string' ? new TextEncoder().encode(val) : val,
-				output: (val) => val,
-			});
-		}
-		const type = getPureBcsSchema(typeSignature.vector);
-		return type ? bcs.vector(type) : null;
-	}
-
-	if ('datatype' in typeSignature) {
-		const pkg = normalizeHaneulAddress(typeSignature.datatype.package);
-
-		if (pkg === normalizeHaneulAddress(MOVE_STDLIB_ADDRESS)) {
-			if (
-				typeSignature.datatype.module === STD_ASCII_MODULE_NAME &&
-				typeSignature.datatype.type === STD_ASCII_STRUCT_NAME
-			) {
-				return bcs.String;
+export function getPureBcsSchema(
+	typeSignature: HaneulClientTypes.OpenSignatureBody,
+): BcsType<any> | null {
+	switch (typeSignature.$kind) {
+		case 'address':
+			return bcs.Address;
+		case 'bool':
+			return bcs.Bool;
+		case 'u8':
+			return bcs.U8;
+		case 'u16':
+			return bcs.U16;
+		case 'u32':
+			return bcs.U32;
+		case 'u64':
+			return bcs.U64;
+		case 'u128':
+			return bcs.U128;
+		case 'u256':
+			return bcs.U256;
+		case 'vector': {
+			if (typeSignature.vector.$kind === 'u8') {
+				return bcs.byteVector().transform({
+					input: (val: string | Uint8Array) =>
+						typeof val === 'string' ? new TextEncoder().encode(val) : val,
+					output: (val) => val,
+				});
 			}
-
-			if (
-				typeSignature.datatype.module === STD_UTF8_MODULE_NAME &&
-				typeSignature.datatype.type === STD_UTF8_STRUCT_NAME
-			) {
-				return bcs.String;
+			const type = getPureBcsSchema(typeSignature.vector);
+			return type ? bcs.vector(type) : null;
+		}
+		case 'datatype': {
+			const { package: pkg, module, name } = parseTypeName(typeSignature.datatype.typeName);
+			const normalizedPkg = normalizeHaneulAddress(pkg);
+
+			if (normalizedPkg === MOVE_STDLIB_ADDRESS) {
+				if (module === 'ascii' && name === 'String') {
+					return bcs.String;
+				}
+				if (module === 'string' && name === 'String') {
+					return bcs.String;
+				}
+				if (module === 'option' && name === 'Option') {
+					const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);
+					return type ? bcs.vector(type) : null;
+				}
 			}
 
-			if (
-				typeSignature.datatype.module === STD_OPTION_MODULE_NAME &&
-				typeSignature.datatype.type === STD_OPTION_STRUCT_NAME
-			) {
-				const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);
-				return type ? bcs.vector(type) : null;
+			if (normalizedPkg === HANEUL_FRAMEWORK_ADDRESS) {
+				if (module === 'object' && name === 'ID') {
+					return bcs.Address;
+				}
 			}
-		}
 
-		if (
-			pkg === normalizeHaneulAddress(HANEUL_FRAMEWORK_ADDRESS) &&
-			typeSignature.datatype.module === OBJECT_MODULE_NAME &&
-			typeSignature.datatype.type === ID_STRUCT_NAME
-		) {
-			return bcs.Address;
+			return null;
 		}
+		case 'typeParameter':
+		case 'unknown':
+			return null;
 	}
-
-	return null;
 }
 
 export function normalizedTypeToMoveTypeSignature(
 	type: HaneulMoveNormalizedType,
-): OpenMoveTypeSignature {
+): HaneulClientTypes.OpenSignature {
 	if (typeof type === 'object' && 'Reference' in type) {
 		return {
-			ref: '&',
+			reference: 'immutable',
 			body: normalizedTypeToMoveTypeSignatureBody(type.Reference),
 		};
 	}
 	if (typeof type === 'object' && 'MutableReference' in type) {
 		return {
-			ref: '&mut',
+			reference: 'mutable',
 			body: normalizedTypeToMoveTypeSignatureBody(type.MutableReference),
 		};
 	}
 
 	return {
-		ref: null,
+		reference: null,
 		body: normalizedTypeToMoveTypeSignatureBody(type),
 	};
 }
 
 function normalizedTypeToMoveTypeSignatureBody(
 	type: HaneulMoveNormalizedType,
-): OpenMoveTypeSignatureBody {
+): HaneulClientTypes.OpenSignatureBody {
 	if (typeof type === 'string') {
 		switch (type) {
 			case 'Address':
-				return 'address';
+				return { $kind: 'address' };
 			case 'Bool':
-				return 'bool';
+				return { $kind: 'bool' };
 			case 'U8':
-				return 'u8';
+				return { $kind: 'u8' };
 			case 'U16':
-				return 'u16';
+				return { $kind: 'u16' };
 			case 'U32':
-				return 'u32';
+				return { $kind: 'u32' };
 			case 'U64':
-				return 'u64';
+				return { $kind: 'u64' };
 			case 'U128':
-				return 'u128';
+				return { $kind: 'u128' };
 			case 'U256':
-				return 'u256';
+				return { $kind: 'u256' };
 			default:
 				throw new Error(`Unexpected type ${type}`);
 		}
 	}
 
 	if ('Vector' in type) {
-		return { vector: normalizedTypeToMoveTypeSignatureBody(type.Vector) };
+		return { $kind: 'vector', vector: normalizedTypeToMoveTypeSignatureBody(type.Vector) };
 	}
 
 	if ('Struct' in type) {
 		return {
+			$kind: 'datatype',
 			datatype: {
-				package: type.Struct.address,
-				module: type.Struct.module,
-				type: type.Struct.name,
+				typeName: `${type.Struct.address}::${type.Struct.module}::${type.Struct.name}`,
 				typeParameters: type.Struct.typeArguments.map(normalizedTypeToMoveTypeSignatureBody),
 			},
 		};
 	}
 
 	if ('TypeParameter' in type) {
-		return { typeParameter: type.TypeParameter };
+		return { $kind: 'typeParameter', index: type.TypeParameter };
 	}
 
 	throw new Error(`Unexpected type ${JSON.stringify(type)}`);
 }
 
-export function pureBcsSchemaFromOpenMoveTypeSignatureBody(
-	typeSignature: OpenMoveTypeSignatureBody,
+export function pureBcsSchemaFromOpenSignatureBody(
+	typeSignature: HaneulClientTypes.OpenSignatureBody,
 ): BcsType<any> {
-	if (typeof typeSignature === 'string') {
-		switch (typeSignature) {
-			case 'address':
-				return bcs.Address;
-			case 'bool':
-				return bcs.Bool;
-			case 'u8':
-				return bcs.U8;
-			case 'u16':
-				return bcs.U16;
-			case 'u32':
-				return bcs.U32;
-			case 'u64':
-				return bcs.U64;
-			case 'u128':
-				return bcs.U128;
-			case 'u256':
-				return bcs.U256;
-			default:
-				throw new Error(`Unknown type signature ${typeSignature}`);
-		}
-	}
-
-	if ('vector' in typeSignature) {
-		return bcs.vector(pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature.vector));
+	switch (typeSignature.$kind) {
+		case 'address':
+			return bcs.Address;
+		case 'bool':
+			return bcs.Bool;
+		case 'u8':
+			return bcs.U8;
+		case 'u16':
+			return bcs.U16;
+		case 'u32':
+			return bcs.U32;
+		case 'u64':
+			return bcs.U64;
+		case 'u128':
+			return bcs.U128;
+		case 'u256':
+			return bcs.U256;
+		case 'vector':
+			return bcs.vector(pureBcsSchemaFromOpenSignatureBody(typeSignature.vector));
+		default:
+			throw new Error(`Expected pure typeSignature, but got ${JSON.stringify(typeSignature)}`);
 	}
-
-	throw new Error(`Expected pure typeSignature, but got ${JSON.stringify(typeSignature)}`);
 }

package/src/transactions/utils.ts

@@ -3,7 +3,7 @@
 
 import { is } from 'valibot';
 
-import type { HaneulMoveNormalizedType } from '../client/index.js';
+import type { HaneulMoveNormalizedType } from '../jsonRpc/index.js';
 import { normalizeHaneulAddress } from '../utils/haneul-types.js';
 import { ArgumentSchema } from './data/internal.js';
 import type { Argument, CallArg, Command } from './data/internal.js';

package/src/utils/constants.ts

@@ -1,16 +1,22 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { normalizeHaneulObjectId } from './haneul-types.js';
-
 export const HANEUL_DECIMALS = 9;
 export const GEUNHWA_PER_HANEUL = BigInt(1000000000);
 
-export const MOVE_STDLIB_ADDRESS = '0x1';
-export const HANEUL_FRAMEWORK_ADDRESS = '0x2';
-export const HANEUL_SYSTEM_ADDRESS = '0x3';
-export const HANEUL_CLOCK_OBJECT_ID = normalizeHaneulObjectId('0x6');
+export const MOVE_STDLIB_ADDRESS =
+	'0x0000000000000000000000000000000000000000000000000000000000000001';
+export const HANEUL_FRAMEWORK_ADDRESS =
+	'0x0000000000000000000000000000000000000000000000000000000000000002';
+export const HANEUL_SYSTEM_ADDRESS =
+	'0x0000000000000000000000000000000000000000000000000000000000000003';
+export const HANEUL_CLOCK_OBJECT_ID =
+	'0x0000000000000000000000000000000000000000000000000000000000000006';
 export const HANEUL_SYSTEM_MODULE_NAME = 'haneul_system';
 export const HANEUL_TYPE_ARG = `${HANEUL_FRAMEWORK_ADDRESS}::haneul::HANEUL`;
-export const HANEUL_SYSTEM_STATE_OBJECT_ID: string = normalizeHaneulObjectId('0x5');
-export const HANEUL_RANDOM_OBJECT_ID = normalizeHaneulObjectId('0x8');
+export const HANEUL_SYSTEM_STATE_OBJECT_ID =
+	'0x0000000000000000000000000000000000000000000000000000000000000005';
+export const HANEUL_RANDOM_OBJECT_ID =
+	'0x0000000000000000000000000000000000000000000000000000000000000008';
+export const HANEUL_DENY_LIST_OBJECT_ID =
+	'0x0000000000000000000000000000000000000000000000000000000000000403';

package/src/utils/dynamic-fields.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { toHex } from '@haneullabs/bcs';
-import { blake2b } from '@noble/hashes/blake2b';
+import { blake2b } from '@noble/hashes/blake2.js';
 
 import type { TypeTag } from '../bcs/bcs.js';
 import { bcs } from '../bcs/index.js';

package/src/utils/haneul-types.ts

@@ -32,6 +32,63 @@ export function isValidHaneulObjectId(value: string): boolean {
 	return isValidHaneulAddress(value);
 }
 
+const MOVE_IDENTIFIER_REGEX = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+
+export function isValidMoveIdentifier(name: string): boolean {
+	return MOVE_IDENTIFIER_REGEX.test(name);
+}
+
+const PRIMITIVE_TYPE_TAGS = [
+	'bool',
+	'u8',
+	'u16',
+	'u32',
+	'u64',
+	'u128',
+	'u256',
+	'address',
+	'signer',
+];
+
+const VECTOR_TYPE_REGEX = /^vector<(.+)>$/;
+
+function isValidTypeTag(type: string): boolean {
+	if (PRIMITIVE_TYPE_TAGS.includes(type)) return true;
+
+	const vectorMatch = type.match(VECTOR_TYPE_REGEX);
+	if (vectorMatch) return isValidTypeTag(vectorMatch[1]);
+
+	if (type.includes('::')) return isValidStructTag(type);
+
+	return false;
+}
+
+function isValidParsedStructTag(tag: StructTag): boolean {
+	if (!isValidHaneulAddress(tag.address) && !isValidNamedPackage(tag.address)) {
+		return false;
+	}
+
+	if (!isValidMoveIdentifier(tag.module) || !isValidMoveIdentifier(tag.name)) {
+		return false;
+	}
+
+	return tag.typeParams.every((param) => {
+		if (typeof param === 'string') {
+			return isValidTypeTag(param);
+		}
+		return isValidParsedStructTag(param);
+	});
+}
+
+export function isValidStructTag(type: string): boolean {
+	try {
+		const tag = parseStructTag(type);
+		return isValidParsedStructTag(tag);
+	} catch {
+		return false;
+	}
+}
+
 export type StructTag = {
 	address: string;
 	module: string;
@@ -46,8 +103,13 @@ function parseTypeTag(type: string): string | StructTag {
 }
 
 export function parseStructTag(type: string): StructTag {
-	const [address, module] = type.split('::');
+	const parts = type.split('::');
+
+	if (parts.length < 3) {
+		throw new Error(`Invalid struct tag: ${type}`);
+	}
 
+	const [address, module] = parts;
 	const isMvrPackage = isValidNamedPackage(address);
 
 	const rest = type.slice(address.length + module.length + 4);

package/src/utils/index.ts

@@ -3,6 +3,7 @@
 
 export { formatAddress, formatDigest } from './format.js';
 export {
+	isValidStructTag,
 	isValidHaneulAddress,
 	isValidHaneulObjectId,
 	isValidTransactionDigest,
@@ -13,18 +14,7 @@ export {
 	HANEUL_ADDRESS_LENGTH,
 } from './haneul-types.js';
 
-export {
-	fromB64,
-	toB64,
-	fromHEX,
-	toHex,
-	toHEX,
-	fromHex,
-	fromBase64,
-	toBase64,
-	fromBase58,
-	toBase58,
-} from '@haneullabs/bcs';
+export { toHex, fromHex, fromBase64, toBase64, fromBase58, toBase58 } from '@haneullabs/bcs';
 export { isValidHaneulNSName, normalizeHaneulNSName } from './haneulns.js';
 
 export {
@@ -38,6 +28,7 @@ export {
 	HANEUL_TYPE_ARG,
 	HANEUL_SYSTEM_STATE_OBJECT_ID,
 	HANEUL_RANDOM_OBJECT_ID,
+	HANEUL_DENY_LIST_OBJECT_ID,
 } from './constants.js';
 
 export { isValidNamedPackage, isValidNamedType } from './move-registry.js';